diff --git a/.gitignore b/.gitignore index c3addae..eedeb63 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,7 @@ -# Benchmark scratch: copied projects and their target dirs. -/results/*/work/ +# Test build output. /tests/smoke/target/ /tests/smoke/Cargo.lock +rustc-ice-*.txt +/tests/errors/target/ +# Benchmark output (scripts/bench*.sh), kept out of git for now. +/results/ diff --git a/README.md b/README.md new file mode 100644 index 0000000..5868005 --- /dev/null +++ b/README.md @@ -0,0 +1,120 @@ +# headstart + +Start dependent crates before their dependencies finish type-checking. + +Every crate waits for the crates it depends on to be fully checked, +function bodies included, before it starts. It doesn't need those bodies +to type-check itself. It compiles against the dependency's interface, the +metadata in its `.rmeta` file. + +Headstart makes rustc write an early metadata file as soon as the +interface is checked, and makes cargo start dependents on it. Each +crate's bodies are then checked while the crates downstream are already +compiling. + +- **`cargo check`:** dependents run to completion on early metadata. +- **`cargo build`:** dependents do all their analysis on early metadata, + then wait for the dependency's full metadata before generating code. + While they wait, they give their job slot back. + +If a body has an error, the build still fails with that error, with the +same diagnostics and exit status as today; only progress lines and the +cross-crate order of JSON messages can differ. Cargo reports a crate's +output only once all its dependencies have finished cleanly, and drops +it if one fails. The costs are work downstream that gets thrown away, +errors reported slightly later, and more memory in use at once (see +[docs/design.md](docs/design.md#risks)). + +## Pieces + +- **rustc, `-Zearly-metadata`** ([patch](patches/rustc)): + - a new `analysis_interfaces` query splits analysis into item + interfaces and function bodies; + - the driver writes `.early-rmeta` between the two; + - crate loading accepts early metadata, and swaps in full metadata + before code generation, pausing for it if necessary. +- **cargo, `CARGO_HEADSTART=1`** ([patch](patches/cargo)): + - passes `-Zearly-metadata` to every compile; + - starts dependents on the early-metadata notification, in both + `check` and `build`; + - tells waiting dependents when a crate fails; + - reports a crate's output only when its dependencies succeeded. + +On rustc's default front end, headstart makes clean builds of 13 real +projects (rust-analyzer, zed, bevy, lemmy, polars and others) up to 54% +faster for `cargo check`, and up to 42% for `cargo build`. None is +slower. With the parallel front end (`-Zthreads=8`), which covers some +of the same ground, it adds up to 25%. + +How it works, what early metadata leaves out, and the risks: +[docs/design.md](docs/design.md). Measurements: +[docs/results.md](docs/results.md). + +## Try it + +```sh +scripts/setup.sh # check out rustc + cargo, apply the patches, build both +``` + +Then, in any Rust project: + +```sh +RUSTC=/path/to/headstart/rustc/build/host/stage1/bin/rustc \ +CARGO_HEADSTART=1 \ + /path/to/headstart/cargo/target/release/cargo check # or build +``` + +With `CARGO_HEADSTART` unset, the patched cargo behaves like upstream, so +the same binaries give a fair baseline. + +`tests/smoke` is a two-crate workspace that shows the effect. Its `slow` +library takes several seconds to check, almost all of it in function +bodies. With headstart on, `app` starts about 0.2 s in instead of +waiting for `slow` to finish. + +`scripts/check-errors.sh` checks the claim about errors on +`tests/errors`. It runs three scenarios (a clean build, an error in a +dependency, an error in the binary) with `cargo check` and `cargo build`, +headstart off and on. It then compares the human-readable output, the +JSON output, the exit status and what the built binary prints. + +`scripts/check-incremental.sh [check|build]` does the same across a +sequence of incremental edits. The steps include adding an `impl Fn` a +dependent calls, and breaking and then fixing an interface. It also +compares the final state against a clean build. + +`scripts/check-swap.sh` makes a library start on its dependency's early +metadata and swap in the full metadata while paused, at every +optimization level. The program built from it must print the same as one +built from full metadata. + +`scripts/sweep.sh` builds all 53 rustc-perf compile benchmarks with +headstart off and on, with `-Zearly-metadata-verify`. It passes when every +build succeeds in both modes with the same diagnostics, and verify reports +nothing. `-c build` sweeps `cargo build`, `-r` the release profile, and +`-t` the parallel front end (`-Zthreads=8`). + +## Benchmarks + +```sh +scripts/bench.sh -n 5 [-c build] path/to/project ... +``` + +This times clean `cargo check` (or `cargo build`) builds, alternating +headstart off and on, +and prints the medians. A project can take cargo arguments after `::` +(`path/to/vaultwarden::--features=sqlite`). `scripts/real-projects.sh +` clones the 13 real projects from [docs/results.md](docs/results.md) +at the commits measured, and prints them in that form: + +```sh +scripts/bench.sh -n 3 -c build $(scripts/real-projects.sh ~/hs-real) +``` + +`scripts/bench-mem.sh` samples the total memory of all rustc processes +during a build, in the project directory itself (run it on an otherwise +idle machine). `scripts/bench-incremental.sh` times incremental rechecks after +editing one function body. `scripts/log-rustc` records when each rustc run +started and ended, so you can see the schedule. The rustc-perf benchmarks +are under `rustc/src/tools/rustc-perf/collector/compile-benchmarks` +(`git -C rustc submodule update --init --depth 1 src/tools/rustc-perf`). diff --git a/config/bootstrap.toml b/config/bootstrap.toml new file mode 100644 index 0000000..9724b2b --- /dev/null +++ b/config/bootstrap.toml @@ -0,0 +1,23 @@ +# Build config for the headstart rustc. scripts/setup.sh copies it to +# rustc/bootstrap.toml (gitignored upstream). +# +# The upstream "compiler" profile, minus the settings that make a dev rustc +# unrepresentatively slow. Benchmarks compare this compiler with and without +# -Zearly-metadata, never against a distributed rustc. +profile = "compiler" +change-id = "ignore" + +[build] +compiler-docs = false +extended = false + +[rust] +debug-assertions = false +debug-logging = false +debuginfo-level = "line-tables-only" +incremental = true +lto = "off" +download-rustc = false + +[llvm] +download-ci-llvm = true diff --git a/docs/design.md b/docs/design.md new file mode 100644 index 0000000..5497096 --- /dev/null +++ b/docs/design.md @@ -0,0 +1,323 @@ +# Design + +## The idea + +A crate's dependents compile against its metadata (`.rmeta`): its items' +signatures, types and trait impls, plus MIR for anything they might +evaluate at compile time, inline or instantiate. Today rustc writes that +metadata only after every function body has been type-checked and +borrow-checked. Most of what that work produces, dependents never need. + +Headstart writes a second, earlier metadata file as soon as the item +interfaces are checked, before any function body is. Dependents start +from it right away, while the crate itself goes on checking its bodies. + +- **`cargo check`** never needs more than that, so dependents run to + completion on early metadata. +- **`cargo build`** also has to generate code and link. A dependent does + all of its analysis against early metadata. It waits for the + dependency's full metadata before code generation, because instantiating + generic and inline functions needs their MIR. A crate that links + (binaries, tests, proc macros, build scripts) also waits for the rlibs + before linking. While it waits, its job slot goes to other work. + +If a body turns out to be wrong, the crate still fails, and so does the +build. Dependents that started early have their work thrown away, and +their output is dropped, so a failing build reports what it reports +today. That's the "dangerous" part: dependents compile against a +promise. Whenever the build succeeds, the promise held, and their results +are exactly what they'd have been. + +## rustc: `-Zearly-metadata` + +### Producing early metadata + +Analysis is split by a new query, `analysis_interfaces`. It runs +everything up to and including the item interface checks (well-formedness, +coherence). `analysis` runs it first, then checks every body. + +The driver writes early metadata between the two, as a step of its own, +just as it writes full metadata after analysis: + +1. `analysis_interfaces`. +2. `write_early_metadata`: + - evaluate statics and synthesize async closures' by-move bodies, the + only definitions that checking bodies would add (encoding freezes + the definitions table). Like body checking, this runs in parallel + under `-Zthreads`, and so does computing the MIR of consts and + const fns for the encoder; + - encode `libfoo-hash.early-rmeta`; + - announce it with an `early-metadata` artifact notification. +3. `analysis`: the bodies. +4. Full metadata, and code generation, as usual. + +The early write happens outside any query, like the full one, so it +doesn't need the dependency tracking of the `analysis` query. The encoder +takes the kind of metadata as a parameter. For early metadata it reads the +definitions table through accessors that depend on `analysis_interfaces` +instead of `analysis` (`TyCtxt::definitions_after_interfaces`, +`iter_local_def_id_after_interfaces`). + +Crates nothing can depend on, such as binaries, write no early metadata. + +### One crate hash for both files + +The two files describe the same crate, so they carry the same crate hash +(SVH). A dependent records the hash of each crate it compiled against, +and anything loaded later is matched against it. That hash is computed +once, from the early metadata, with upstream's scheme: the encoded bytes +plus a supplement of the HIR hash and the tracked options. Full metadata +carries the same one. + +It's a complete identity from the start: +- the early metadata's bytes cover the interface, including every + dependency's hash; +- the HIR hash in the supplement covers every body; +- the tracked options are included too. + +Full metadata is a deterministic function of exactly those inputs, so a +change to any function body changes the hash, even one that doesn't +touch the early metadata. Incremental compilation relies on this: it +uses a dependency's crate hash to decide whether results derived from it +are still valid, including code inlined or instantiated from its bodies. + +### What encoding still forces + +The encoder asks the query system for whatever the metadata contains, so +anything a crate's interface depends on is computed on demand, bodies +included: + +- **Opaque types.** The hidden type of an `impl Trait` in a signature + comes from type-checking the defining function's body. +- **Constants.** The encoder records the MIR (or value) of consts, + `const fn`s and array lengths, which means building their bodies. +- **Statics.** Evaluated before the write, as above. +- **Coroutines.** `async fn` and `async` block state machines are encoded + with their witnesses, because dependents read them to decide whether a + future is `Send`. + +Everything else waits until after the write. + +### What early metadata leaves out + +- **Definitions nested in other bodies.** Closures, inline consts and + const arguments (`foo::<3>()`) inside a function body are definitions of + their own, typed by type-checking the enclosing body. Early metadata + encodes them only when the enclosing body is an **interface body**, one + whose type-checking the interface itself depends on: + - bodies the encoder records MIR for: consts, const fns and coroutines + (`async` bodies); + - statics; + - functions that define an opaque type (`-> impl Trait`, `async fn`), + and the bodies that may define a `type Alias = impl Trait`. + + A dependent reaches a body's contents only through a type or MIR that + came from an interface body, so it can't name the left-out ones before + its own code generation. By then it reads full metadata. + + The set is a function of the code alone. A first version instead + encoded a nested definition whenever its body happened to be + type-checked already, which it learned by peeking at the query cache. + That made the metadata depend on evaluation order, and on what an + incremental session recomputed rather than loaded. `-Zearly-metadata-verify` + reports any left-out definition whose body was type-checked during the + write anyway, which would be a body the set missed. The benchmark sweep + reports none (see [results.md](results.md)). +- **Optimized MIR of functions, and their deduced parameter + attributes.** Dependents need them only for code generation, from full + metadata. Only coroutines' optimized MIR is in early metadata, because + dependents compute a future's layout during analysis. + + Computing any other function's optimized MIR would type-check its body. + It would also run the MIR inliner, which asks each dependency whether + it has MIR for the callee. A dependency loaded from early metadata says + no, and the query system would keep that answer after the swap to full + metadata. With optimization on, a dependent then fails to find MIR it + needs for code generation. `-Zearly-metadata-verify` reports any query + that only full metadata can answer when it's asked about a crate still + loaded from early metadata. + + A crate compiled without code generation (`cargo check`) never swaps in + its dependencies' full metadata, so its own full metadata skips the + reachable set too. Upstream computes it there but never reads it, and + at opt-level 1 or more computing it runs the MIR inliner. +- **Exported symbols, cross-crate inlinability and the panic strategy.** + Computing them collects the crate's monomorphizations, or walks its + bodies. Early metadata doesn't compute the reachable set either, which + decides which MIR full metadata encodes. Only code generation and + linking read any of these, from full metadata. + +### Consuming early metadata + +Writing early metadata first deletes the crate's stale full metadata and +rlib. So a full `.rmeta` or `.rlib` next to early metadata is always from +the same compilation or a later one, never an earlier one. + +With the flag, crate loading also considers `libfoo-hash.early-rmeta`, both +for `--extern foo=libfoo-hash.rmeta` and when searching directories for +transitive dependencies. It loads the full metadata if it exists, and the +early metadata otherwise. A crate that links and loads a dependency from +metadata also records where the dependency's rlib will be written. The +file may not exist yet. + +Before code generation, `CStore::load_full_metadata` replaces every +dependency loaded from early metadata with its full metadata: + +- **Waiting.** If the full file doesn't exist yet, rustc waits for it + (see *Pausing* below). It checks that the file carries the same crate + hash. +- **Swapping.** It loads the full blob into a new `CrateMetadata`, keeping + what the session decided while loading the crate: its crate number + mapping, dependency kind, and whether it's used. +- **Lookups.** From then on, the crate store's lookup returns the new + entry. The early entry stays alive, so anything already decoded from it + stays valid. +- **The type cache.** rustc caches types decoded from metadata by their + position in the blob. The swapped crate's entries are dropped, because + a position means something else in the full blob. +- **Source files.** These are imported again from the full blob's table, + because an imported file records its index in the table it came from. + +Before linking, `CStore::wait_for_rlibs` waits for the recorded rlib +paths to exist; rlibs are written atomically. With cross-crate LTO, which +reads dependencies' rlibs during code generation, it waits before code +generation instead. + +### Pausing + +When rustc has to wait for a dependency's full metadata or rlib: + +1. It announces a `wait-metadata` artifact notification naming the file + (the same kind for an rlib), and polls for it. +2. The build tool stops counting it as running, so its job slot can go to + other work. +3. Once the file exists, rustc announces `resume` and continues. The + build tool counts it as running again. + +rustc never touches the jobserver for this. A resumed compilation can +briefly put the build one job over its limit, until the next job +finishes. Making it wait for a free slot instead starved it: it +competed for tokens with work started in its place, often on the +critical path (see [results.md](results.md)). + +The crate graph has no cycles, so what a paused compilation waits for is +always running or queued, and waiting can't deadlock. + +**Retraction.** If a crate fails after writing early metadata, its +promise is withdrawn: the early file is deleted. rustc does this when a +compilation ends with errors or panics, through linking, which is where +code generation finishes and the rlib is written. A build tool has to +do it when the compiler is killed or aborts. A compilation waiting for that crate's full metadata or +rlib sees the early metadata disappear, and stops with an error. Its +output is dropped anyway (below). + +## cargo: `CARGO_HEADSTART=1` + +With the variable set: + +- **Every rustc compile gets `-Zearly-metadata`.** Crates with dependents + write early metadata, and every crate can load it. +- **Dependents start on the `early-metadata` notification.** + - Every unit rustc compiles, in check, build or test mode, starts on its + rlib dependencies' early metadata. That includes binaries, tests, + proc macros and build scripts. + - Proc-macro and dylib dependencies still need a full build. + - Cargo already pipelined `cargo build` libraries on the `metadata` + notification. Headstart extends that to every unit, and to + `cargo check`. + - A unit's dependents are released once, on whichever notification + comes first. Cargo reads the notification's `emit` field for the new + kinds, and still recognizes full metadata by its `.rmeta` extension. +- **No waiting for the whole dependency tree.** Cargo normally makes a + unit that links wait for the *full* build of every transitive + dependency. Under headstart, rustc waits for the rlibs itself right + before linking, so those edges go. +- **Pause accounting.** + - A paused compilation (a `wait-metadata` notification) doesn't count as + running, so its slot goes to other work. + - When it announces `resume`, it counts as running again. Cargo starts + no new work until the number of running jobs is back under the + limit. +- **Retraction.** When a unit fails, cargo deletes its early metadata, in + case rustc crashed before it could. +- **Only error-free dependencies get their output reported.** A unit that + started before its dependencies finished is provisional. Its + diagnostics, JSON messages and result are held until every dependency + has finished cleanly, then emitted in their original order. If a + dependency fails, they're dropped. A held unit still frees its job slot + and unblocks its dependents. + + So a failing build prints the same diagnostics, JSON messages and exit + status as today. What can differ is output that already depends on + timing today: + - progress lines: `Checking`/`Compiling` for dependents that started + early, and `Finished`; + - "waiting for other jobs to finish" and lock waits (`Blocking`); + - the order of JSON messages across crates, which cargo doesn't + guarantee. + +With the variable unset, cargo behaves exactly as upstream. + +## Risks + +- **A crate's own errors surface a little later.** They're delayed by the + early write: 4 ms for the median crate in cargo-0.87.1's build, and + 249 ms at p99 (see [results.md](results.md); measured before the + latest changes to what the early write computes). That was one of the + two reasons the 2019 attempt stopped ([rust-lang/rust#64112]). A + dependent also competes for CPU with the crate it started on, which + this figure doesn't capture. +- **Wasted work on failure.** When a crate fails, its dependents' work so + far is thrown away. The output is still the same as today. +- **Incremental builds.** `-Zearly-metadata` is a tracked option, so + toggling it starts a fresh incremental session. The crate hash covers + every body (see above), so dependents' incremental results stay sound. + `scripts/check-incremental.sh` runs a sequence of edits under `cargo + check` and `cargo build`. It checks that each step matches the same + step with headstart off, and that the final state matches a clean + build. +- **Platforms.** Retraction deletes a file that dependents may have + memory-mapped. That's fine on Unix; on Windows, deleting an open file + can fail, and that path hasn't been tested. +- **Memory.** More compilers are alive at once, including paused ones, + so peak memory can rise (see [results.md](results.md#peak-memory), + measured on the first, check-only version). Cargo doesn't cap the + number of paused compilers yet. +- **The parallel front end.** `-Zthreads` uses the same idle cores. On + top of it, headstart adds up to 25% on real projects, less on wide + ones, and within noise of nothing on a few (see + [results.md](results.md)). +- **Contention.** A resumed compilation doesn't wait for a free job + slot, and headstart keeps more compilations running. On a saturated + machine that can slow the critical path. Cargo doesn't adjust its + scheduling for this yet. +- **Coverage.** If the metadata needs something from a body that the + encoder doesn't know to force, the failure would be a compiler crash + (an ICE): a missing entry in a dependent, or a definition created after + the table is frozen. The benchmark sweeps and `-Zearly-metadata-verify` + are how we look for those. They're evidence, not a proof. + +## Prior art + +In 2019, Nicholas Nethercote moved metadata writing before type-checking +and borrow-checking in [rust-lang/rust#64112]. He measured debug and +release builds with a single metadata file. That file had to carry the +MIR dependents need for code generation, so the early write still forced +most of the analysis. He saw at most 1.07×, and abandoned the change +because "it wasn't much of a win, and it would slightly delay error +message emission" +([blog](https://blog.mozilla.org/nnethercote/2019/10/11/how-to-speed-up-the-rust-compiler-some-more-in-2019/)). + +Headstart differs in two ways. Early metadata is a separate file with +only what analysis needs, and dependents wait for the full file only +before code generation. It also covers `cargo check`, which cargo didn't +pipeline at all. + +David Lattimore's +["Speeding up rustc by being lazy"](https://davidlattimore.github.io/posts/2024/06/05/speeding-up-rustc-by-being-lazy.html) +(2024) proposes a pipeline whose first step writes an `.rmeta` with "only +what's needed to check dependent crates", and then finishes the error +checking. Headstart is close to that first step, with the full metadata +following in the same compilation. + +[rust-lang/rust#64112]: https://github.com/rust-lang/rust/pull/64112 diff --git a/docs/results.md b/docs/results.md new file mode 100644 index 0000000..15f0854 --- /dev/null +++ b/docs/results.md @@ -0,0 +1,626 @@ +# Results + +Timings come from clean builds taken with `scripts/bench.sh`, of the +rustc-perf benchmarks (in +`rustc/src/tools/rustc-perf/collector/compile-benchmarks`) and of 13 real +projects (`scripts/real-projects.sh`). Each run alternates headstart off +and on, using the same patched rustc and cargo. With headstart off, both +behave like upstream. Tables give medians. Memory and incremental +numbers come from `scripts/bench-mem.sh` and +`scripts/bench-incremental.sh`. + +The first sections cover the current version: early metadata as a +separate file, used by both `cargo check` and `cargo build`, on the +rustc-perf benchmarks and on 13 real projects (rust-analyzer, zed, bevy, +lemmy and others). The later sections are measurements of the first, +check-only version. They're kept for the error-delay, memory, clippy, +rustdoc and incremental numbers, which haven't been measured again since; +their timing tables are superseded by the current ones. + +## Correctness (current version) + +- **Benchmark sweeps** (`scripts/sweep.sh`). + - **What they build:** all 53 compile benchmarks (not counting the + `-new-solver`, `-nll`, `-tiny` and `-threads4` variants of others; + about 20 are a single crate, which headstart can't help but mustn't + break), with headstart + off and on, on Linux with 16 jobs, with `-Zearly-metadata-verify`. + - **Six sweeps:** `cargo check` and `cargo build`, each in debug, in + release (`-r`), and in debug with `-Zthreads=8` (`-t`). + - **Result:** in every sweep, 52 benchmarks pass in both modes with + identical diagnostics, and verify reports nothing. + - stm32f4 fails in both modes because it needs a device feature; its + build-script panic messages differ only in the thread ID. +- **Real projects.** 13 projects, 312 builds, all succeeded with + identical diagnostics. The one exception is noise from the parallel + front end itself (see "Real projects"). +- **`scripts/check-swap.sh`** makes a library start on its dependency's + early metadata and swap in the full metadata while paused. At + opt-levels 0, 1, 2, 3 and s, the program built from it prints the same + as one built from full metadata. +- **Test suites.** + - Both run with the patches applied and headstart off, their default, + so they check that the patches change nothing else. They don't + exercise early metadata itself. + - rustc's UI suite: 22129 passed, 0 failed, 259 ignored, on Linux. + - cargo's test suite: 4034 passed. The single failure, + `aaa_trigger_cross_compile_disabled_check`, only flags that there's no + cross-compilation target installed. +- **Errors.** `scripts/check-errors.sh` runs three scenarios on + `tests/errors`: a clean build, an error in a dependency's body, and an + error in the binary. It runs each with `cargo check` and `cargo build`, + in human and JSON formats, with headstart off and on. Diagnostics and + exit status are identical, and so is what the built binary prints. + What can differ is output that already depends on timing: + - progress lines (`Checking`, `Compiling`, `Finished`, "waiting for + other jobs"); + - the order of JSON messages across crates, which cargo doesn't + guarantee, and headstart holds a crate's messages until its + dependencies finish; + - lock-wait messages. +- **Incremental.** `scripts/check-incremental.sh check` and + `scripts/check-incremental.sh build` run ten edit steps each. Every step + matches headstart-off, and the final state matches a clean build. + +The sweeps found two bugs in the swap to full metadata, both fixed: + +- **A stale type cache.** rustc caches decoded types by their position + in a crate's metadata. After the swap, positions in the full file + collided with cached ones from the early file. This crashed + cargo-0.87.1 and large-workspace. +- **Stale-looking full metadata.** Incremental compilation reused a full + `.rmeta` by hard-linking it, which kept its old modification time, so + it looked older than this compilation's early metadata. Writing early + metadata now deletes the crate's stale full metadata and rlib first, + so a full file next to early metadata is never an older one. + +## Timing, current version: Linux, AMD EPYC 9554P, 16 jobs, 5 runs + +These were measured before the three fixes under "Bugs found by the real +projects". Two of them apply only with optimization or `-Zthreads`. The +third skips work in `cargo check` that was never read, so it can only +make the check column faster; it wasn't re-timed. + +The 21 are a fixed set of multi-crate benchmarks, kept the same across +rounds so that versions compare. All 53 benchmarks are in the sweeps. + +Build and check were measured back to back in one session, alternating +headstart off and on. Another user's two long-running compilations kept +the VM's load average at 3–5 throughout. Off and on runs share that +load equally, so the savings compare, but absolute times are a little +higher than on an idle machine. All 420 builds succeeded. + +"Previous" is the saving measured for the version before this one, on +an idle VM (commit 0a09236). Since then: + +- binaries, tests, proc macros and build scripts also start on early + metadata, and wait for rlibs only before linking; +- a resumed compilation no longer waits for a free job slot (see + [design.md](design.md#pausing)). Measured with `scripts/critical-path.py`, + resumed compilations on the critical path had spent seconds waiting + for a slot while work started in their place held it. + +| project | build today | build headstart | saved | previous | check today | check headstart | saved | previous | +|---|--:|--:|--:|--:|--:|--:|--:|--:| +| ripgrep-14.1.1 | 15.01 s | 9.88 s | 34% | 23% | 10.15 s | 5.53 s | 46% | 47% | +| serde_derive-1.0.219 | 8.33 s | 5.23 s | 37% | 9% | 5.62 s | 3.61 s | 36% | 35% | +| piston-image | 8.33 s | 5.72 s | 31% | 32% | 6.11 s | 3.99 s | 35% | 36% | +| eza-0.21.2 | 33.36 s | 21.79 s | 35% | 19% | 27.03 s | 18.94 s | 30% | 30% | +| clap_derive-4.5.32 | 7.89 s | 5.73 s | 27% | 8% | 5.83 s | 4.06 s | 30% | 31% | +| unicode-normalization-0.1.24 | 2.13 s | 1.62 s | 24% | 24% | 1.90 s | 1.32 s | 31% | 31% | +| tt-muncher | 2.30 s | 1.56 s | 32% | 10% | 1.79 s | 1.29 s | 28% | 28% | +| image-0.25.6 | 26.07 s | 20.35 s | 22% | 18% | 19.32 s | 13.94 s | 28% | 23% | +| html5ever | 16.93 s | 12.35 s | 27% | 12% | 16.61 s | 12.18 s | 27% | 13% | +| hyper-1.6.0 | 2.87 s | 2.19 s | 24% | 18% | 2.41 s | 1.84 s | 24% | 22% | +| nalgebra-0.33.0 | 24.11 s | 18.46 s | 23% | 21% | 22.57 s | 17.61 s | 22% | 20% | +| regex-automata-0.4.8 | 9.56 s | 7.50 s | 22% | 18% | 6.73 s | 5.28 s | 22% | 21% | +| wg-grammar | 10.51 s | 8.25 s | 22% | 19% | 9.91 s | 7.98 s | 19% | 15% | +| cargo-0.87.1 | 95.71 s | 83.35 s | 13% | 11% | 51.17 s | 41.48 s | 19% | 22% | +| cargo | 30.04 s | 25.26 s | 16% | 6% | 20.76 s | 17.00 s | 18% | 18% | +| html5ever-0.31.0 | 8.30 s | 6.84 s | 18% | 13% | 7.62 s | 6.47 s | 15% | 11% | +| projection-caching | 11.63 s | 10.11 s | 13% | 6% | 11.18 s | 9.50 s | 15% | 9% | +| syn-2.0.101 | 4.93 s | 4.26 s | 14% | 15% | 3.51 s | 3.06 s | 13% | 14% | +| diesel-2.2.10 | 40.44 s | 36.78 s | 9% | 7% | 38.18 s | 34.74 s | 9% | 7% | +| cranelift-codegen-0.119.0 | 28.86 s | 26.45 s | 8% | 7% | 19.99 s | 18.17 s | 9% | 8% | +| encoding | 1.48 s | 1.39 s | 6% | 6% | 1.10 s | 1.04 s | 5% | 8% | + +- **`cargo build` gains most.** Proc-macro chains (serde_derive, + clap_derive) and binaries at the end of the graph (eza, ripgrep, + html5ever) no longer wait for every rlib to be finished before they + start. +- **`cargo check`** changes less, since check units already started on + early metadata. The largest gains (html5ever, projection-caching, + image) come from binaries starting early and from the pause fix. +- **The slot-waiting variant in between** (commit 8c1b8a4) made cargo-0.87.1 8% slower to build and 19% slower to + check: cargo held back new work until a resumed compilation got a + slot, while it competed for slots with libgit2's C build. Resuming + without a slot fixed that. + +## With the parallel front end, current version (`RUSTFLAGS=-Zthreads=8`) + +The same 21 benchmarks, with `-Zthreads=8` on both sides, 5 runs each, +after the fixes described under "Bugs found by the real projects". The +load average was about 5 when each part started. + +| project | build today | build headstart | saved | check today | check headstart | saved | +|---|--:|--:|--:|--:|--:|--:| +| unicode-normalization-0.1.24 | 1.27 s | 0.96 s | 24% | 1.15 s | 0.78 s | 32% | +| ripgrep-14.1.1 | 8.83 s | 7.10 s | 20% | 4.63 s | 3.45 s | 25% | +| clap_derive-4.5.32 | 3.88 s | 2.86 s | 26% | 2.70 s | 2.08 s | 23% | +| projection-caching | 5.32 s | 4.35 s | 18% | 5.31 s | 4.11 s | 23% | +| hyper-1.6.0 | 1.38 s | 1.18 s | 14% | 1.23 s | 0.98 s | 20% | +| html5ever | 8.67 s | 7.04 s | 19% | 8.57 s | 7.15 s | 17% | +| encoding | 0.94 s | 0.94 s | 0% | 0.83 s | 0.70 s | 16% | +| serde_derive-1.0.219 | 4.28 s | 3.59 s | 16% | 2.62 s | 2.20 s | 16% | +| image-0.25.6 | 15.61 s | 14.26 s | 9% | 9.90 s | 8.37 s | 15% | +| nalgebra-0.33.0 | 8.64 s | 7.59 s | 12% | 8.15 s | 7.13 s | 13% | +| tt-muncher | 1.85 s | 1.56 s | 16% | 1.44 s | 1.29 s | 10% | +| wg-grammar | 5.82 s | 5.24 s | 10% | 5.83 s | 5.26 s | 10% | +| cargo | 19.39 s | 16.89 s | 13% | 14.11 s | 12.81 s | 9% | +| syn-2.0.101 | 2.41 s | 2.29 s | 5% | 1.76 s | 1.61 s | 9% | +| html5ever-0.31.0 | 4.38 s | 3.93 s | 10% | 4.16 s | 3.83 s | 8% | +| piston-image | 4.54 s | 4.14 s | 9% | 3.20 s | 2.93 s | 8% | +| diesel-2.2.10 | 14.77 s | 13.80 s | 7% | 14.97 s | 13.93 s | 7% | +| regex-automata-0.4.8 | 4.00 s | 3.68 s | 8% | 2.58 s | 2.41 s | 7% | +| eza-0.21.2 | 19.43 s | 18.67 s | 4% | 16.20 s | 15.22 s | 6% | +| cranelift-codegen-0.119.0 | 15.03 s | 14.70 s | 2% | 10.30 s | 10.01 s | 3% | +| cargo-0.87.1 | 57.00 s | 54.50 s | 4% | 33.04 s | 32.86 s | 1% | + +- **Nothing is slower.** Headstart saves 14–32% on chain-shaped builds + (ripgrep, clap_derive, unicode-normalization, projection-caching, + hyper), and a few percent on the large ones, where the parallel front + end already fills the cores. +- **regex-automata** was slower in every earlier measurement with + `-Zthreads` (up to 7%); it's 7–8% faster now. Like zola, it has large static tables that were evaluated + on one thread before the early write. +- **encoding's** 16% in check is 0.13 s on a sub-second build. + +## Real projects: Linux, AMD EPYC 9554P, 16 jobs, 3 runs + +Thirteen open-source projects, cloned at the commits listed in +`scripts/real-projects.sh`, which reproduces this set: + +```sh +scripts/bench.sh -n 3 -c check $(scripts/real-projects.sh ~/hs-real) +``` + +- **Notoriously slow builds:** rust-analyzer, bevy, nushell, wasmtime, + typst, helix, polars, zed. +- **Web apps and services:** lemmy (actix, diesel/postgres), vaultwarden + (rocket, diesel/sqlite), atuin (axum, sqlx), zola, lldap. +- **Setup:** all with the default dev profile, from clean. + - Several projects pin a toolchain in `rust-toolchain.toml`. Every + build here uses the patched rustc, so the pins don't apply. + - meilisearch was dropped: its current code doesn't compile with + this rustc, with or without headstart. +- **Load:** another user's jobs kept the VM's load average at 3–5 + before each pass started. Off and on runs alternate, so both share it. +- **Result:** all 312 builds succeeded, with identical diagnostics in both + modes, except lemmy under `-Zthreads` (below). + +| project | check today | check headstart | saved | build today | build headstart | saved | +|---|--:|--:|--:|--:|--:|--:| +| rust-analyzer | 90.1 s | 41.5 s | 54% | 137.9 s | 79.9 s | 42% | +| polars | 172.4 s | 87.4 s | 49% | 341.2 s | 241.4 s | 29% | +| wasmtime | 150.5 s | 79.9 s | 47% | 244.6 s | 155.8 s | 36% | +| helix | 44.2 s | 30.5 s | 31% | 78.0 s | 64.4 s | 17% | +| bevy | 120.9 s | 85.3 s | 29% | 195.8 s | 136.9 s | 30% | +| zed | 280.0 s | 204.3 s | 27% | 425.1 s | 318.2 s | 25% | +| lemmy | 448.8 s | 330.8 s | 26% | 532.3 s | 371.6 s | 30% | +| typst | 86.0 s | 63.2 s | 26% | 142.2 s | 123.4 s | 13% | +| lldap | 69.0 s | 56.6 s | 18% | 100.8 s | 77.5 s | 23% | +| atuin | 125.2 s | 109.3 s | 13% | 162.6 s | 127.0 s | 22% | +| vaultwarden | 116.4 s | 107.1 s | 8% | 164.7 s | 150.4 s | 9% | +| nushell | 81.0 s | 75.5 s | 7% | 122.1 s | 112.2 s | 8% | +| zola | 117.2 s | 114.7 s | 2% | 126.1 s | 125.9 s | 0% | + +- **Deep workspaces gain most.** rust-analyzer, polars and wasmtime chain + their own crates one after another. rust-analyzer and polars average + about 3 compilations running at once out of 16 without headstart, and + 6–7 with it. +- **Wide builds that end in one big crate gain least.** Out of 16 job + slots, zola, vaultwarden and atuin average 5–7 compilations running. + Their builds end with one crate compiling alone: + - zola: `minify_html_common`, 81 s of generated tables; + - vaultwarden: diesel, then the `vaultwarden` binary; + - atuin: sqlx and its own crates, after SQLite's C build. + + Headstart can start a crate earlier, but it can't split one. +- zed and lemmy, the two slowest, save 1.3 and 2 minutes on check, and + 1.8 and 2.7 minutes on build. + +### With the parallel front end (`-Zthreads=8`) + +The same projects, with `RUSTFLAGS=-Zthreads=8` on both sides. + +| project | check today | check headstart | saved | build today | build headstart | saved | +|---|--:|--:|--:|--:|--:|--:| +| rust-analyzer | 40.1 s | 30.2 s | 25% | 70.1 s | 54.3 s | 22% | +| typst | 63.4 s | 49.6 s | 22% | 133.6 s | 131.3 s | 2% | +| wasmtime | 114.7 s | 99.2 s | 14% | 136.4 s | 118.6 s | 13% | +| lemmy | 194.9 s | 168.8 s | 13% | 244.3 s | 210.3 s | 14% | +| polars | 87.8 s | 76.7 s | 13% | 194.4 s | 176.7 s | 9% | +| zed | 234.3 s | 221.2 s | 6% | 362.8 s | 329.0 s | 9% | +| nushell | 69.4 s | 65.7 s | 5% | 107.6 s | 108.3 s | −1% | +| bevy | 78.3 s | 75.4 s | 4% | 127.3 s | 118.1 s | 7% | +| helix | 26.9 s | 26.0 s | 3% | 53.0 s | 45.9 s | 13% | +| vaultwarden | 65.3 s | 63.3 s | 3% | 101.1 s | 97.2 s | 4% | +| lldap | 51.5 s | 50.5 s | 2% | 78.6 s | 74.9 s | 5% | +| atuin | 109.9 s | 110.5 s | −1% | 136.1 s | 128.7 s | 5% | +| zola | 73.1 s | 74.6 s | −2% | 84.3 s | 80.9 s | 4% | + +- **The two overlap.** The parallel front end alone does much of what + headstart does: rust-analyzer's check goes from 90 s to 40–42 s with + either one, and to 30 s with both. +- **On top of `-Zthreads`,** headstart adds up to 25%, mostly on deep + workspaces. +- **Three results are within noise of even:** atuin and zola in check + (−1%, −2%), and nushell in build (−1%). Their run ranges overlap. +- **wasmtime's check runs were noisy** (79–135 s off, 75–111 s on) + while the VM's other load came and went. +- **lemmy's diagnostics differ between modes, but not because of + headstart.** + - The parallel front end reports some "overflow evaluating the + requirement" warnings at different lines from run to run, with or + without headstart. + - Those warnings are the only difference. + - With the default front end, all runs are identical. + +A first version of this pass found zola 80% *slower* with headstart. See +"Bugs found by the real projects" below. + +### Bugs found by the real projects + +Until this round, the rustc-perf sweeps built everything in debug mode +with the default front end. The real projects, and a release sweep +added because of them, went down three paths those sweeps never did. +All three are fixed, and each is now covered by a sweep or a test. + +1. **Optimized dependencies: "missing optimized MIR".** + - **Seen in:** typst builds its dependencies at opt-level 2, and zed + builds its proc macros at 3. Both failed with headstart on. + - **Cause:** writing early metadata computed deduced parameter + attributes, which optimizes every function body. The MIR inliner then + asked dependencies still loaded from early metadata whether they had + MIR. They said no, and the answer stayed cached after the swap. + - **Fix:** early metadata no longer records deduced parameter + attributes, and records optimized MIR only for coroutines. + `scripts/check-swap.sh` reproduces the bug at opt-level 2 and 3 + without the fix. +2. **Statics evaluated on one thread.** + - **Seen in:** zola under `-Zthreads=8`, 80% slower with headstart. + The crate at the end of its build (`minify_html_common`, large + generated tables) took 78 s to reach its early write, against 26 s + for all of its analysis with `-Zthreads` alone. + - **Cause:** the step before the early write evaluated statics in a + sequential loop, where body checking uses a parallel one. + - **Fix:** that loop is parallel now, and consts' MIR is prefetched in + parallel for early metadata, as for full metadata. This also turned + small losses on bevy, helix and lldap into gains, and moved typst + from 4% to 22%. +3. **`cargo check --release` asked early crates for MIR.** + - **Seen in:** the release sweep, where `-Zearly-metadata-verify` + reported 2,819 cases. + - **Cause:** in a check build, a crate's full metadata still computed + the reachable set. At opt-level ≥ 1 that optimizes MIR, asking + dependencies that check builds never swap to full. + - **Harm:** the result is never read without code generation, so no + build failed; the work was wasted and the answers wrong. + - **Fix:** it's skipped there now. + + +## Earlier measurements (first, check-only version) + +### Correctness + +**macOS (M2 Max).** A sweep over all 53 compile benchmarks (not counting +the `-new-solver`, `-nll`, `-tiny` and `-threads4` variants) built each +one with headstart off and on: + +- **No ICEs**, and every benchmark's exit status matched between modes. + Three benchmarks fail in both modes, for reasons unrelated to headstart: + - libc 0.2.172 uses `#[deprecated]` on foreign modules, which this + rustc rejects; + - stm32f4's build script needs a device feature, which rustc-perf + passes and a plain `cargo check` doesn't; + - tokio-webpush-simple depends on native-tls 0.1, which doesn't build + on macOS. + + syn wasn't run: fetching its dependencies needed git authentication. +- **Same diagnostics.** In the timing runs, the sorted `cargo check` + output was identical between modes for every benchmark. + +**Linux (x86_64, AMD EPYC, 16 jobs).** The same sweep passes in both +modes for 52 of 53 benchmarks, including libc, syn and +tokio-webpush-simple, with identical diagnostics. stm32f4 fails in both +modes because it needs a device feature. Its build-script panic +messages differ only in the thread ID. + +The sweep found four bugs in the first version of the rustc patch. Each +one was a case where encoding early touched something that only exists +after bodies are checked: + +- `required_panic_strategy` scanned every body's MIR. +- A const argument inside a body (`SlimNeon::<1>::new`, in aho-corasick) + had no type yet. +- A synthetic lifetime definition was looked up in the HIR, which it + isn't part of (textwrap). +- A static inside a closure created a definition after the table was + frozen (bstr). + +[design.md](design.md) describes the fixes. + +rustc's UI suite passes with the patch applied and the flag off: +21967 passed, 0 failed, 421 ignored. + +### The interface-body set + +Every benchmark, built with headstart on and `-Zearly-metadata-verify`, +checks that no body was type-checked during the early write without +being in the interface set. There are no reports on the 49 benchmarks +that build. + +The first run found one bookkeeping bug. For a const argument inside a +closure, the encoder recorded the closure as the enclosing body instead +of the function that contains it. nom's `bits::take` returns +`impl Fn`, so its body is an interface body, and those constants were +wrongly left out. + +### Incremental builds + +`scripts/check-incremental.sh` applies ten steps to `tests/errors`, with +headstart off and on in separate directories: + +- an initial build; +- a body edit; +- adding an `impl Fn` whose closure a dependent calls; +- changing that closure; +- breaking an interface, then fixing it; +- adding a body error, then fixing it; +- an edit in the binary; +- touching every file. + +Every step prints the same output in both modes, and the final state +matches a clean build. + +It found two bugs: + +1. **A crash on the first incremental build.** Metadata encoding asserts + that it runs outside dependency tracking, and the early write ran + inside the `analysis` query. +2. **A stale-metadata risk behind it.** In incremental mode, encoding + reuses the previous `.rmeta` when its inputs are unchanged. Normally it + depends on `analysis`, which is how it notices new items, and the early + write had dropped that dependency. It now depends on the crate's item + list. + +### Clippy and rustdoc + +Measured on the first, check-only version. Clippy runs as check units, +so it reads early metadata with headstart on. rustdoc units start only +once their dependencies have finished, so they read full metadata; the +comparison checks that the check units underneath produce the same +docs. + +- **Clippy.** `cargo check` with `clippy-driver` as the workspace + wrapper, which is what `cargo clippy` does, over all 49 benchmarks that + build. The results are identical with headstart off and on: 5534 clippy + diagnostics in total. Six benchmarks fail in both modes on + deny-by-default lints, with identical output. +- **rustdoc.** `cargo doc`, including every dependency's docs, on eight + benchmarks: ripgrep, hyper, regex-automata, image, html5ever, tt-muncher, + unicode-normalization and eza (up to 30,000 files). Six are + byte-identical. + - The other two differ only in rustdoc's merged search index, and, on + macOS's case-insensitive filesystem, in whether rustix's `_Exit` or + `_exit` page keeps its file name. + - Both already depend on scheduling order: changing `-j` with headstart + *off* reproduces both differences. + +### Errors + +**Same output.** `scripts/check-errors.sh` builds `tests/errors` in three +scenarios, with headstart off and on, in both human and JSON formats: + +- a clean build (with one warning); +- an error in the body of `slow`, the crate `mid` and `app` depend on; +- an error in `app`. + +Diagnostics, JSON messages and exit status are identical in every case. +When `slow` fails, `mid` and `app` have already started, but their output +is dropped (see [design.md](design.md#cargo-cargo_headstart1)). The only +difference is their `Checking` progress lines. + +**Delay of a crate's own errors.** A crate's body errors now come after +the early metadata write. Across the 280 crates in cargo-0.87.1's build +that write early metadata, that write takes: + +| | median | p90 | p99 | max | +|---|--:|--:|--:|--:| +| early write | 4 ms | 34 ms | 249 ms | 532 ms | + +That's 5.2 s in total, against 2.3 s for the same crates' metadata today, +which is written at the end. The difference is work the metadata needs +from bodies (constants, opaque types, async functions), done earlier +rather than added. An earlier revision of this version also computed +the reachable set, which walks every inline and generic body. That took the +total to 18.8 s, with a median of 23 ms and a maximum of 1.6 s. + +The error at the start of `slow`, in `tests/errors`, is printed at 0.17 s +in both modes. + +### Cargo's test suite + +With the patch applied and headstart off, cargo's own test suite passes: +4027 passed, 1 failed. The failure, +`aaa_trigger_cross_compile_disabled_check`, only flags that this machine +has no cross-compilation target installed. + +### Timing: Linux, AMD EPYC 9554P, 16 jobs, 5 runs + +These runs started once the VM was idle (load average 0.57). They use +that version's final patches, which include two fixes that made an +earlier Linux run understate headstart: + +- **Binaries waited for their whole dependency tree.** Cargo made a + check-mode binary wait for the full check of every transitive + dependency, because a binary normally links. Check builds don't link. +- **Metadata encoding checked bodies early.** The encoder computed the + reachable set, which forced type-checking of every inline and generic + body before the early write. + +| project | today | headstart | saved | first run | +|---|--:|--:|--:|--:| +| ripgrep-14.1.1 | 10.31 s | 5.45 s | 47% | 30% | +| serde_derive-1.0.219 | 5.76 s | 3.66 s | 36% | 35% | +| piston-image | 6.19 s | 4.02 s | 35% | 23% | +| clap_derive-4.5.32 | 5.86 s | 4.04 s | 31% | 30% | +| unicode-normalization-0.1.24 | 1.93 s | 1.34 s | 31% | 25% | +| tt-muncher | 1.82 s | 1.31 s | 28% | 14% | +| eza-0.21.2 | 26.66 s | 19.68 s | 26% | 18% | +| hyper-1.6.0 | 2.53 s | 1.87 s | 26% | 25% | +| cargo-0.87.1 | 49.78 s | 39.14 s | 21% | 16% | +| image-0.25.6 | 19.33 s | 15.33 s | 21% | 13% | +| regex-automata-0.4.8 | 6.87 s | 5.43 s | 21% | 16% | +| nalgebra-0.33.0 | 22.19 s | 18.71 s | 16% | 16% | +| cargo (old) | 20.23 s | 17.16 s | 15% | 17% | +| wg-grammar | 9.67 s | 8.22 s | 15% | 6% | +| syn-2.0.101 | 3.66 s | 3.14 s | 14% | 14% | +| encoding | 1.11 s | 1.04 s | 6% | 6% | +| cranelift-codegen-0.119.0 | 19.65 s | 18.77 s | 4% | 2% | +| projection-caching | 11.14 s | 10.66 s | 4% | 2% | +| diesel-2.2.10 | 37.71 s | 37.66 s | 0% | 1% | +| html5ever | 16.59 s | 16.79 s | −1% | −1% | +| html5ever-0.31.0 | 7.53 s | 7.70 s | −2% | 0% | + +- **html5ever-0.31.0 is slightly slower.** Headstart was slower in 4 of + 5 runs, by about 0.15 s. That fits the early write's cost on a build + whose critical path can't use it. +- **Everything else is flat or faster.** +- **The sweep still passes.** Rerun on these patches: 52 of 53 + benchmarks pass in both modes with identical diagnostics, and stm32f4 + fails in both. + +### Peak memory + +These runs sample the total resident memory of all rustc processes every +100 ms during clean `cargo check` builds, on Linux with 16 jobs, median +of 3: + +| project | peak today | peak with headstart | change | time today | time with headstart | +|---|--:|--:|--:|--:|--:| +| cargo-0.87.1 | 2.81 GB | 2.69 GB | −4% | 52.5 s | 41.5 s | +| eza-0.21.2 | 2.21 GB | 2.24 GB | +1% | 28.1 s | 21.1 s | +| ripgrep-14.1.1 | 1.63 GB | 1.68 GB | +3% | 10.2 s | 5.6 s | +| image-0.25.6 | 1.92 GB | 2.17 GB | +13% | 19.9 s | 15.7 s | +| nalgebra-0.33.0 | 0.76 GB | 1.05 GB | +39% | 22.9 s | 19.0 s | +| diesel-2.2.10 | 0.75 GB | 0.75 GB | −1% | 38.9 s | 39.5 s | + +- **Mostly flat.** With more crates running at once, more of them are + in memory together. +- **nalgebra is the outlier:** 0.29 GB more, because its large crates now + overlap. +- **That version's final patches didn't cost speed.** The times, + measured on those patches, match the timing table above: the interface-body rule and the + incremental fixes didn't change it. + +### With the parallel front end (`-Zthreads=8`) + +The parallel front end spreads a crate's type-checking, borrow-checking +and other analysis over up to 8 threads inside one rustc process. Those +threads take tokens from cargo's jobserver, so with `-j16` the whole +build still runs at most 16 things at once, whether they're processes or +threads. + +These builds interleave four configurations in one session, on Linux +with 16 jobs: plain; headstart; `RUSTFLAGS=-Zthreads=8`; and both. Each +is a clean `cargo check`, median of 3, with the min–max in brackets: + +| project | plain | headstart | `-Zthreads=8` | `-Zthreads=8` + headstart | +|---|--:|--:|--:|--:| +| cargo-0.87.1 | 52.54 s (51.42–53.05) | 42.16 s (42.13–43.06) | 30.23 s (29.89–30.75) | 28.79 s (28.05–29.10) | +| eza-0.21.2 | 27.61 s (26.77–27.88) | 19.81 s (19.67–19.84) | 14.64 s (14.33–14.80) | 14.31 s (14.16–14.37) | +| image-0.25.6 | 19.47 s (19.20–19.76) | 15.82 s (15.69–16.37) | 9.33 s (9.16–9.49) | 9.06 s (8.98–9.90) | +| ripgrep-14.1.1 | 10.31 s (10.23–10.66) | 5.64 s (5.58–5.81) | 4.24 s (4.01–4.31) | 3.32 s (3.25–3.36) | +| regex-automata-0.4.8 | 7.06 s (7.01–7.17) | 5.59 s (5.55–5.70) | 2.55 s (2.48–2.73) | 2.64 s (2.63–2.72) | +| serde_derive-1.0.219 | 5.69 s (5.62–6.14) | 3.65 s (3.61–3.67) | 2.50 s (2.50–2.66) | 2.07 s (2.07–2.09) | +| hyper-1.6.0 | 2.48 s (2.47–2.60) | 1.83 s (1.81–1.85) | 1.07 s (1.03–1.07) | 0.87 s (0.86–0.96) | + +- **The parallel front end alone is the bigger win everywhere:** 42–64% + faster than plain, where headstart alone is 19–45%. +- **On top of it, headstart helps chain-shaped builds most:** ripgrep + saves 0.92 s (22%), hyper 0.20 s (19%) and serde_derive 0.43 s (17%). + The large builds gain a little: cargo-0.87.1 1.44 s (5%), image 0.27 s + (3%), eza 0.33 s (2%). Only cargo-0.87.1's run ranges don't overlap + the `-Zthreads=8` ones. +- **regex-automata gets 0.09 s (4%) slower** with both, likely the early + write's cost where the parallel front end has already removed the wait. +- An earlier, separate 3-run session showed cargo-0.87.1 3% slower with + both. Interleaved, it's 5% faster. At this size, the combination is + within a few percent either way. + +The parallel front end is still nightly-only and off by default. Once it +ships, headstart's value is the last column against the third. + +### Incremental edit loop + +These runs edit one function body in cargo's own workspace, then run an +incremental `cargo check`, with a warm target directory per mode. Each +number is the median of 5 edits on Linux with 16 jobs: + +| edited file | today | headstart | saved | +|---|--:|--:|--:| +| `crates/cargo-util/src/paths.rs` | 6.07 s | 5.72 s | 6% | +| `crates/cargo-util-schemas/src/manifest/mod.rs` | 6.28 s | 5.80 s | 8% | +| `src/compiler/mod.rs` (the `cargo` crate) | 5.65 s | 5.28 s | 7% | + +The gain is smaller than in clean builds, because only the edited crate +and its dependents recheck. But it applies to every edit. Even an edit to +the top `cargo` library saves time, because cargo's binaries start on +the library's early metadata. + +### Timing: Apple M2 Max, 12 jobs, 5 runs (first version) + +| project | today | headstart | saved | +|---|--:|--:|--:| +| clap_derive-4.5.32 | 8.94 s | 3.68 s | 59%* | +| serde_derive-1.0.219 | 3.22 s | 2.30 s | 29% | +| regex-automata-0.4.8 | 3.49 s | 2.54 s | 27% | +| unicode-normalization-0.1.24 | 1.16 s | 0.86 s | 26% | +| tt-muncher | 1.47 s | 1.11 s | 24% | +| hyper-1.6.0 | 1.15 s | 0.98 s | 15% | +| image-0.25.6 | 12.14 s | 10.48 s | 14% | +| cargo (old) | 13.04 s | 11.68 s | 10%* | +| ripgrep-14.1.1 | 4.65 s | 4.21 s | 9% | +| html5ever | 9.52 s | 8.75 s | 8% | +| nalgebra-0.33.0 | 11.23 s | 10.33 s | 8% | +| piston-image | 3.46 s | 3.24 s | 6% | +| projection-caching | 11.48 s | 10.74 s | 6%* | +| wg-grammar | 5.90 s | 5.65 s | 4% | +| diesel-2.2.10 | 22.43 s | 21.77 s | 3% | +| encoding | 0.71 s | 0.69 s | 3% | +| cargo-0.87.1 | 31.78 s | 31.38 s | 1% | +| eza-0.21.2 | 17.20 s | 17.17 s | 0% | +| html5ever-0.31.0 | 4.67 s | 4.69 s | 0% | +| cranelift-codegen-0.119.0 | 10.75 s | 11.16 s | −4% | + +\* Noisy: the machine was also syncing files during part of the run. For +example, clap_derive's baseline runs ranged from 4.2 s to 12.2 s. The +rows without a star were consistent across runs. For instance, every +regex-automata, unicode-normalization and serde_derive run was faster +with headstart on. + +### Where it doesn't help + +- **CPU-bound builds.** cargo-0.87.1 has about 211 s of rustc work. On + the 12-core Mac, the cores are busy almost until the last crate starts, + and the first version of headstart saved 1%. On 16 cores the current + version saves 19% for check and 13% for build. Starting crates earlier helps only when there's an + idle core to run them on. +- **Build scripts and proc macros.** Build scripts, and C code compiled + from them, are full builds and gain nothing. The same holds for proc + macros (syn → serde_derive → ...). In cargo-0.87.1, the libgit2 C build + sits on the critical path. Headstart makes more crates ready at once, + and they can crowd that build out. +- **Single-crate benchmarks.** With no dependents, there's nothing to + start early. diff --git a/patches/cargo/0001-headstart.patch b/patches/cargo/0001-headstart.patch new file mode 100644 index 0000000..3459393 --- /dev/null +++ b/patches/cargo/0001-headstart.patch @@ -0,0 +1,693 @@ +diff --git a/src/compiler/build_runner/mod.rs b/src/compiler/build_runner/mod.rs +index 4bf69f6..5bb5e02 100644 +--- a/src/compiler/build_runner/mod.rs ++++ b/src/compiler/build_runner/mod.rs +@@ -763,6 +763,15 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> { + /// Returns whether when `parent` depends on `dep` if it only requires the + /// metadata file from `dep`. + pub fn only_requires_rmeta(&self, parent: &Unit, dep: &Unit) -> bool { ++ // Headstart: a compile unit starts on its library dependencies' early ++ // metadata (`-Zearly-metadata`), written before their bodies are ++ // checked. Check units need nothing more. Units that generate code ++ // wait for full metadata before code generation, and units that link ++ // wait for the rlibs before linking; rustc does both. Dependencies ++ // that must be fully built (proc macros, dylibs) still are. ++ if headstart() && headstart_starts_early(parent, dep) { ++ return true; ++ } + // We're only a candidate for requiring an `rmeta` file if we + // ourselves are building an rlib, + !parent.requires_upstream_objects() +@@ -773,6 +782,13 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> { + && dep.mode == CompileMode::Build + } + ++ /// Whether headstart is on (`CARGO_HEADSTART=1`): units are compiled with ++ /// `-Zearly-metadata`, and a unit's dependents start as soon as its early ++ /// metadata is written, before its function bodies are checked. ++ pub fn headstart_enabled(&self) -> bool { ++ headstart() ++ } ++ + /// Returns whether when `unit` is built whether it should emit metadata as + /// well because some compilations rely on that. + pub fn rmeta_required(&self, unit: &Unit) -> bool { +@@ -816,3 +832,25 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> { + } + } + } ++ ++/// Whether, with headstart, `parent` can start on `dep`'s early metadata. ++fn headstart_starts_early(parent: &Unit, dep: &Unit) -> bool { ++ let compiled_by_rustc = matches!( ++ parent.mode, ++ CompileMode::Build | CompileMode::Test | CompileMode::Check { .. } ++ ); ++ let dep_is_rlib = dep.target.is_lib() && !dep.requires_upstream_objects(); ++ compiled_by_rustc ++ && dep_is_rlib ++ && if parent.mode.is_check() { ++ dep.mode == (CompileMode::Check { test: false }) ++ } else { ++ dep.mode == CompileMode::Build ++ } ++} ++ ++fn headstart() -> bool { ++ static ON: std::sync::LazyLock = ++ std::sync::LazyLock::new(|| std::env::var_os("CARGO_HEADSTART").is_some_and(|v| v == "1")); ++ *ON ++} +diff --git a/src/compiler/job_queue/job_state.rs b/src/compiler/job_queue/job_state.rs +index b866821..e4f2649 100644 +--- a/src/compiler/job_queue/job_state.rs ++++ b/src/compiler/job_queue/job_state.rs +@@ -50,6 +50,9 @@ pub struct JobState<'a, 'gctx> { + /// sending a double message later on. + rmeta_required: Cell, + ++ /// Whether `rmeta_produced` has released this unit's dependents already. ++ rmeta_announced: Cell, ++ + /// Manages locks for build units when fine grain locking is enabled. + lock_manager: Arc, + +@@ -74,6 +77,7 @@ impl<'a, 'gctx> JobState<'a, 'gctx> { + messages, + output, + rmeta_required: Cell::new(rmeta_required), ++ rmeta_announced: Cell::new(false), + lock_manager, + warning_handling, + _marker: marker::PhantomData, +@@ -88,7 +92,7 @@ impl<'a, 'gctx> JobState<'a, 'gctx> { + if let Some(dedupe) = self.output { + writeln!(dedupe.gctx.shell().out(), "{}", stdout)?; + } else { +- self.messages.push_bounded(Message::Stdout(stdout)); ++ self.messages.push_bounded(Message::Stdout(self.id, stdout)); + } + Ok(()) + } +@@ -99,7 +103,7 @@ impl<'a, 'gctx> JobState<'a, 'gctx> { + shell.print_ansi_stderr(stderr.as_bytes())?; + shell.err().write_all(b"\n")?; + } else { +- self.messages.push_bounded(Message::Stderr(stderr)); ++ self.messages.push_bounded(Message::Stderr(self.id, stderr)); + } + Ok(()) + } +@@ -144,12 +148,29 @@ impl<'a, 'gctx> JobState<'a, 'gctx> { + }); + } + ++ /// Headstart: rustc paused, waiting for a dependency's full metadata or ++ /// rlib. ++ pub fn paused(&self) { ++ self.messages.push(Message::Paused(self.id)); ++ } ++ ++ /// Headstart: a paused rustc resumed. ++ pub fn resumed(&self) { ++ self.messages.push(Message::Resumed(self.id)); ++ } ++ + /// A method used to signal to the coordinator thread that the rmeta file + /// for an rlib has been produced. This is only called for some rmeta + /// builds when required, and can be called at any time before a job ends. +- /// This should only be called once because a metadata file can only be +- /// produced once! ++ /// ++ /// Only the first call has an effect. With headstart, rustc announces ++ /// early metadata and then full metadata, and both call this. + pub fn rmeta_produced(&self) { ++ // With headstart, rustc announces early and then full metadata; ++ // dependents are released on the first. ++ if self.rmeta_announced.replace(true) { ++ return; ++ } + self.rmeta_required.set(false); + self.messages + .push(Message::Finish(self.id, Artifact::Metadata, Ok(()))); +diff --git a/src/compiler/job_queue/mod.rs b/src/compiler/job_queue/mod.rs +index a581e11..1b7b30b 100644 +--- a/src/compiler/job_queue/mod.rs ++++ b/src/compiler/job_queue/mod.rs +@@ -210,6 +210,43 @@ struct DrainState<'gctx> { + /// How many jobs we've finished + finished: usize, + per_package_future_incompat_reports: Vec, ++ ++ /// Headstart: output of units whose dependencies haven't finished yet. ++ provisional: Provisional, ++ ++ /// Headstart: jobs paused, waiting for a dependency's full metadata or ++ /// rlib. They don't hold a job slot, so theirs goes to other work. A ++ /// paused job resumes as soon as its file is written, without waiting for ++ /// a slot, so it can't be starved by work started in its place; it counts ++ /// as running again, and no new job starts until enough jobs finish. ++ paused: HashSet, ++} ++ ++/// With headstart (`CARGO_HEADSTART=1`), a unit starts on a dependency's ++/// early metadata, and the dependency can still fail afterwards. Cargo only ++/// reports output from units whose dependencies are error-free: while any ++/// dependency is unconfirmed, a unit's diagnostics, JSON messages and result ++/// are held, and if a dependency fails they're dropped. A failing build ++/// prints what it prints today. A held unit gives up its job slot as usual. ++#[derive(Default)] ++struct Provisional { ++ enabled: bool, ++ /// The job each started unit runs as. ++ ids: HashMap, ++ /// Units that finished cleanly, with every dependency confirmed. ++ confirmed: HashSet, ++ /// Units that failed. ++ failed: HashSet, ++ /// For each unit with unconfirmed dependencies, which ones. ++ waiting_on: HashMap>, ++ /// Output held for waiting units, in order. ++ held: HashMap>, ++ /// Waiting units that already finished, with their result. ++ finished: HashMap)>, ++ /// Units with a failed dependency: their output is dropped. ++ tainted: HashSet, ++ /// Errors of units released after they finished, for the drain loop. ++ released_errors: Vec, + } + + /// Count of warnings, used to print a summary after the job succeeds +@@ -357,8 +394,8 @@ enum Artifact { + + enum Message { + Run(JobId, String), +- Stdout(String), +- Stderr(String), ++ Stdout(JobId, String), ++ Stderr(JobId, String), + + // This is for general stderr output from subprocesses + Diagnostic { +@@ -389,6 +426,12 @@ enum Message { + Finish(JobId, Artifact, CargoResult<()>), + FutureIncompatReport(JobId, Vec), + SectionTiming(JobId, SectionTiming), ++ ++ /// Headstart: rustc paused, waiting for a dependency's full metadata or ++ /// rlib. ++ Paused(JobId), ++ /// Headstart: a paused rustc resumed. ++ Resumed(JobId), + UnusedExterns(JobId, std::collections::BTreeSet), + } + +@@ -453,7 +496,17 @@ impl<'gctx> JobQueue<'gctx> { + // the target as well. This should ensure that edges changed to + // `Metadata` propagate upwards `All` dependencies to anything that + // transitively contains the `Metadata` edge. +- if unit.requires_upstream_objects() { ++ // ++ // Headstart: a unit compiled by rustc needs only its direct ++ // dependencies' metadata, whose own dependencies' metadata came first. ++ // A check unit never links; one that does waits for the rlibs itself ++ // before linking. ++ let rustc_waits_for_rlibs = build_runner.headstart_enabled() ++ && matches!( ++ unit.mode, ++ CompileMode::Build | CompileMode::Test | CompileMode::Check { .. } ++ ); ++ if unit.requires_upstream_objects() && !rustc_waits_for_rlibs { + for dep in dependencies { + depend_on_deps_of_deps(build_runner, &mut queue_deps, dep.unit.clone()); + } +@@ -523,6 +576,11 @@ impl<'gctx> JobQueue<'gctx> { + ), + finished: 0, + per_package_future_incompat_reports: Vec::new(), ++ provisional: Provisional { ++ enabled: build_runner.headstart_enabled(), ++ ..Default::default() ++ }, ++ paused: HashSet::default(), + }; + + // Create a helper thread for acquiring jobserver tokens +@@ -607,8 +665,13 @@ impl<'gctx> DrainState<'gctx> { + Ok(()) + } + ++ /// Jobs holding a job slot: active ones, minus paused ones (headstart). ++ fn slot_holders(&self) -> usize { ++ self.active.len().saturating_sub(self.paused.len()) ++ } ++ + fn has_extra_tokens(&self) -> bool { +- self.active.len() < self.tokens.len() + 1 ++ self.slot_holders() < self.tokens.len() + 1 + } + + fn handle_event( +@@ -616,7 +679,9 @@ impl<'gctx> DrainState<'gctx> { + build_runner: &mut BuildRunner<'_, '_>, + event: Message, + ) -> Result<(), ErrorToHandle> { +- let warning_handling = build_runner.bcx.gctx.warning_handling()?; ++ let Some(event) = self.hold(build_runner, event) else { ++ return Ok(()); ++ }; + match event { + Message::Run(id, cmd) => { + build_runner +@@ -627,10 +692,10 @@ impl<'gctx> DrainState<'gctx> { + self.timings + .unit_start(build_runner, id, self.active[&id].clone()); + } +- Message::Stdout(out) => { ++ Message::Stdout(_, out) => { + writeln!(build_runner.bcx.gctx.shell().out(), "{}", out)?; + } +- Message::Stderr(err) => { ++ Message::Stderr(_, err) => { + let mut shell = build_runner.bcx.gctx.shell(); + shell.print_ansi_stderr(err.as_bytes())?; + shell.err().write_all(b"\n")?; +@@ -678,34 +743,11 @@ impl<'gctx> DrainState<'gctx> { + // from the `active` map ... + Artifact::All => { + trace!("end: {:?}", id); ++ self.paused.remove(&id); + self.finished += 1; + let unit = self.active.remove(&id).unwrap(); +- // An error could add an entry for a `Unit` +- // with 0 warnings but having fixable +- // warnings be disallowed +- let count = self +- .warning_count +- .get(&id) +- .filter(|count| 0 < count.total) +- .cloned(); +- if let Some(count) = count { +- let denied_warnings = +- warning_handling == WarningHandling::Deny && 0 < count.lints; +- self.report_warning_count( +- build_runner, +- &unit, +- &count, +- &build_runner.bcx.rustc().workspace_wrapper, +- denied_warnings, +- ); +- let stop_on_warnings = denied_warnings +- && !build_runner.bcx.build_config.keep_going +- && !count.supplanted_by_errors; +- if stop_on_warnings { +- result = Err(anyhow::format_err!( +- "warnings are denied by `build.warnings` configuration" +- )) +- } ++ if let Err(denied) = self.report_warnings(build_runner, id, &unit) { ++ result = Err(denied); + } + unit + } +@@ -718,7 +760,12 @@ impl<'gctx> DrainState<'gctx> { + }; + debug!("end ({:?}): {:?}", unit, result); + match result { +- Ok(()) => self.finish(id, &unit, artifact, build_runner)?, ++ Ok(()) => { ++ self.finish(id, &unit, artifact, build_runner)?; ++ if artifact == Artifact::All { ++ self.settle(build_runner, id, true); ++ } ++ } + Err(_) if build_runner.bcx.unit_can_fail_for_docscraping(&unit) => { + build_runner + .failed_scrape_units +@@ -728,6 +775,7 @@ impl<'gctx> DrainState<'gctx> { + self.queue.finish(&unit, &artifact); + } + Err(error) => { ++ self.settle(build_runner, id, false); + let show_warnings = true; + self.emit_log_messages(&unit, build_runner, show_warnings)?; + self.back_compat_notice(build_runner, &unit)?; +@@ -762,11 +810,188 @@ impl<'gctx> DrainState<'gctx> { + Message::SectionTiming(id, section) => { + self.timings.unit_section_timing(build_runner, id, §ion); + } ++ Message::Paused(id) => { ++ self.paused.insert(id); ++ } ++ Message::Resumed(id) => { ++ self.paused.remove(&id); ++ } + } + + Ok(()) + } + ++ /// Reports a finished unit's warning count. Returns an error if its ++ /// warnings are denied. ++ fn report_warnings( ++ &mut self, ++ build_runner: &mut BuildRunner<'_, '_>, ++ id: JobId, ++ unit: &Unit, ++ ) -> CargoResult<()> { ++ let warning_handling = build_runner.bcx.gctx.warning_handling()?; ++ // An error could add an entry for a `Unit` ++ // with 0 warnings but having fixable ++ // warnings be disallowed ++ let count = self ++ .warning_count ++ .get(&id) ++ .filter(|count| 0 < count.total) ++ .cloned(); ++ if let Some(count) = count { ++ let denied_warnings = warning_handling == WarningHandling::Deny && 0 < count.lints; ++ self.report_warning_count( ++ build_runner, ++ unit, ++ &count, ++ &build_runner.bcx.rustc().workspace_wrapper, ++ denied_warnings, ++ ); ++ let stop_on_warnings = denied_warnings ++ && !build_runner.bcx.build_config.keep_going ++ && !count.supplanted_by_errors; ++ if stop_on_warnings { ++ anyhow::bail!("warnings are denied by `build.warnings` configuration") ++ } ++ } ++ Ok(()) ++ } ++ ++ /// Headstart: holds `event` if it belongs to a unit with unconfirmed ++ /// dependencies, and drops it if the unit has a failed dependency. ++ /// Returns the event if it should be handled now. ++ fn hold(&mut self, build_runner: &mut BuildRunner<'_, '_>, event: Message) -> Option { ++ if !self.provisional.enabled { ++ return Some(event); ++ } ++ let id = match &event { ++ Message::Stdout(id, _) ++ | Message::Stderr(id, _) ++ | Message::Diagnostic { id, .. } ++ | Message::WarningCount { id, .. } ++ | Message::Warning { id, .. } ++ | Message::Finish(id, Artifact::All, _) => *id, ++ _ => return Some(event), ++ }; ++ if self.provisional.tainted.contains(&id) { ++ if let Message::Finish(..) = event { ++ self.active.remove(&id); ++ self.paused.remove(&id); ++ self.finished += 1; ++ } ++ return None; ++ } ++ if !self.provisional.waiting_on.contains_key(&id) { ++ return Some(event); ++ } ++ match event { ++ Message::Finish(id, _, result) => { ++ // Free the job slot and unblock dependents now; only the ++ // report waits. ++ let unit = self.active.remove(&id).unwrap(); ++ self.paused.remove(&id); ++ self.finished += 1; ++ if result.is_ok() { ++ if let Err(error) = self.finish(id, &unit, Artifact::All, build_runner) { ++ self.provisional.released_errors.push(error.into()); ++ } ++ } ++ self.provisional.finished.insert(id, (unit, result)); ++ } ++ event => self.provisional.held.entry(id).or_default().push(event), ++ } ++ None ++ } ++ ++ /// Headstart: `id` finished cleanly with every dependency confirmed ++ /// (`ok`), or failed. Releases or drops its dependents' output. ++ fn settle(&mut self, build_runner: &mut BuildRunner<'_, '_>, id: JobId, ok: bool) { ++ if !self.provisional.enabled { ++ return; ++ } ++ if ok { ++ self.provisional.confirmed.insert(id); ++ } else { ++ self.provisional.failed.insert(id); ++ } ++ let dependents: Vec = self ++ .provisional ++ .waiting_on ++ .iter() ++ .filter(|(_, deps)| deps.contains(&id)) ++ .map(|(&dependent, _)| dependent) ++ .collect(); ++ for dependent in dependents { ++ if !ok { ++ self.taint(dependent); ++ continue; ++ } ++ let deps = self.provisional.waiting_on.get_mut(&dependent).unwrap(); ++ deps.remove(&id); ++ if deps.is_empty() { ++ self.provisional.waiting_on.remove(&dependent); ++ self.release(build_runner, dependent); ++ } ++ } ++ } ++ ++ /// Headstart: a dependency of `id` failed, so drop its output, and its ++ /// dependents' output. ++ fn taint(&mut self, id: JobId) { ++ if !self.provisional.tainted.insert(id) { ++ return; ++ } ++ self.provisional.waiting_on.remove(&id); ++ self.provisional.held.remove(&id); ++ self.provisional.finished.remove(&id); ++ let dependents: Vec = self ++ .provisional ++ .waiting_on ++ .iter() ++ .filter(|(_, deps)| deps.contains(&id)) ++ .map(|(&dependent, _)| dependent) ++ .collect(); ++ for dependent in dependents { ++ self.taint(dependent); ++ } ++ } ++ ++ /// Headstart: every dependency of `id` is confirmed. Emits its held ++ /// output, and its result if it has finished. ++ fn release(&mut self, build_runner: &mut BuildRunner<'_, '_>, id: JobId) { ++ for event in self.provisional.held.remove(&id).unwrap_or_default() { ++ if let Err(err) = self.handle_event(build_runner, event) { ++ self.provisional.released_errors.push(err); ++ } ++ } ++ let Some((unit, result)) = self.provisional.finished.remove(&id) else { ++ return; ++ }; ++ let result = match self.report_warnings(build_runner, id, &unit) { ++ Err(denied) => Err(denied), ++ Ok(()) => result, ++ }; ++ match result { ++ Ok(()) => self.settle(build_runner, id, true), ++ Err(error) => { ++ self.settle(build_runner, id, false); ++ let show_warnings = true; ++ for result in [ ++ self.emit_log_messages(&unit, build_runner, show_warnings), ++ self.back_compat_notice(build_runner, &unit), ++ ] { ++ if let Err(err) = result { ++ self.provisional.released_errors.push(err.into()); ++ } ++ } ++ self.provisional.released_errors.push(ErrorToHandle { ++ error, ++ print_always: true, ++ }); ++ } ++ } ++ } ++ + // This will also tick the progress bar as appropriate + fn wait_for_events(&mut self) -> Vec { + // Drain all events at once to avoid displaying the progress bar +@@ -779,7 +1004,7 @@ impl<'gctx> DrainState<'gctx> { + if events.is_empty() { + loop { + self.tick_progress(); +- self.tokens.truncate(self.active.len() - 1); ++ self.tokens.truncate(self.slot_holders().saturating_sub(1)); + match self.messages.pop(Duration::from_millis(500)) { + Some(message) => { + events.push(message); +@@ -843,6 +1068,9 @@ impl<'gctx> DrainState<'gctx> { + if let Err(event_err) = self.handle_event(build_runner, event) { + self.handle_error(&mut build_runner.bcx.gctx.shell(), &mut errors, event_err); + } ++ for err in std::mem::take(&mut self.provisional.released_errors) { ++ self.handle_error(&mut build_runner.bcx.gctx.shell(), &mut errors, err); ++ } + } + } + self.progress.clear(); +@@ -926,7 +1154,13 @@ impl<'gctx> DrainState<'gctx> { + let new_err = new_err.into(); + if new_err.print_always || err_state.count == 0 { + crate::display_error(&new_err.error, shell); +- if err_state.count == 0 && !self.active.is_empty() { ++ // Headstart: jobs whose dependency failed don't count; their ++ // output is dropped. ++ let waiting_for_others = self ++ .active ++ .keys() ++ .any(|id| !self.provisional.tainted.contains(id)); ++ if err_state.count == 0 && waiting_for_others { + self.progress.indicate_error(); + let _ = shell.warn("build failed, waiting for other jobs to finish..."); + } +@@ -1003,6 +1237,22 @@ impl<'gctx> DrainState<'gctx> { + debug!("start {}: {:?}", id, unit); + + assert!(self.active.insert(id, unit.clone()).is_none()); ++ if self.provisional.enabled { ++ let deps: Vec = build_runner ++ .unit_deps(unit) ++ .iter() ++ .filter_map(|dep| self.provisional.ids.get(&dep.unit).copied()) ++ .filter(|dep| !self.provisional.confirmed.contains(dep)) ++ .collect(); ++ if deps.iter().any(|dep| self.provisional.failed.contains(dep)) { ++ self.provisional.tainted.insert(id); ++ } else if !deps.is_empty() { ++ self.provisional ++ .waiting_on ++ .insert(id, deps.into_iter().collect()); ++ } ++ self.provisional.ids.insert(unit.clone(), id); ++ } + + let messages = self.messages.clone(); + let is_fresh = job.freshness().is_fresh(); +@@ -1078,7 +1328,12 @@ impl<'gctx> DrainState<'gctx> { + let count = self.warning_count.entry(id).or_default(); + count.total += 1; + if lint { +- let unit = self.active.get(&id).unwrap(); ++ // A held unit (see `Provisional`) may have finished already. ++ let unit = self ++ .active ++ .get(&id) ++ .or_else(|| self.provisional.finished.get(&id).map(|(unit, _)| unit)) ++ .unwrap(); + // If this is an upstream dep but we *do* want warnings, make sure that they + // don't fail compilation. + if unit.is_local() { +diff --git a/src/compiler/mod.rs b/src/compiler/mod.rs +index fae7bab..838c33c 100644 +--- a/src/compiler/mod.rs ++++ b/src/compiler/mod.rs +@@ -395,6 +395,8 @@ fn rustc( + output_options.show_diagnostics = false; + } + let env_config = Arc::clone(build_runner.bcx.gctx.env_config()?); ++ let headstart = build_runner.headstart_enabled(); ++ + return Ok(Work::new(move |state| { + // Artifacts are in a different location than typical units, + // hence we must assure the crate- and target-dependent +@@ -452,6 +454,20 @@ fn rustc( + } + } + ++ // Headstart: dependents that started on this unit's early metadata ++ // wait for its full metadata before code generation. If this unit ++ // fails, its early metadata is withdrawn (deleted), which tells them ++ // it won't come. rustc does this itself on errors; this covers crashes. ++ let early_metadata: Vec = if headstart { ++ outputs ++ .iter() ++ .filter(|output| output.path.extension() == Some(OsStr::new("rmeta"))) ++ .map(|output| root.join(&output.path).with_extension("early-rmeta")) ++ .collect() ++ } else { ++ Vec::new() ++ }; ++ + state.running(&rustc); + let timestamp = paths::set_invocation_time(&fingerprint_dir)?; + if let Some(sbom) = sbom { +@@ -514,6 +530,12 @@ fn rustc( + format!("could not compile {name}{errors}{warnings}") + }); + ++ if result.is_err() { ++ for path in &early_metadata { ++ let _ = paths::remove_file(path); ++ } ++ } ++ + if let Err(e) = result { + if let Some(diagnostic) = failed_scrape_diagnostic { + state.warning(diagnostic); +@@ -1346,6 +1368,12 @@ fn build_base_args( + } + } + ++ // Headstart: rustc writes early metadata for dependents to start on, and ++ // loads dependencies from theirs, waiting for full metadata before code ++ // generation. ++ if build_runner.headstart_enabled() { ++ cmd.arg("-Zearly-metadata"); ++ } + if unit.mode.is_check() { + cmd.arg("--emit=dep-info,metadata"); + } else if !build_runner +@@ -2359,13 +2387,35 @@ fn on_stderr_line_inner( + struct ArtifactNotification<'a> { + #[serde(borrow)] + artifact: Cow<'a, str>, ++ #[serde(borrow, default)] ++ emit: Option>, + } + + if let Ok(artifact) = serde_json::from_str::>(compiler_message.get()) { + trace!("found directive from rustc: `{}`", artifact.artifact); +- if artifact.artifact.ends_with(".rmeta") { +- debug!("looks like metadata finished early!"); +- state.rmeta_produced(); ++ match artifact.emit.as_deref() { ++ // Headstart: early metadata (`-Zearly-metadata`) is enough for ++ // dependents to start; full metadata follows. ++ Some("early-metadata") => { ++ debug!("early metadata written"); ++ state.rmeta_produced(); ++ } ++ // Headstart: rustc paused before code generation or linking, ++ // waiting for a dependency's full metadata or rlib. It doesn't ++ // hold a job slot meanwhile. ++ Some("wait-metadata") => { ++ debug!("waiting for `{}`", artifact.artifact); ++ state.paused(); ++ } ++ Some("resume") => { ++ debug!("resumed"); ++ state.resumed(); ++ } ++ _ if artifact.artifact.ends_with(".rmeta") => { ++ debug!("looks like metadata finished early!"); ++ state.rmeta_produced(); ++ } ++ _ => {} + } + return Ok(false); + } diff --git a/patches/rustc/0001-early-metadata.patch b/patches/rustc/0001-early-metadata.patch new file mode 100644 index 0000000..fe47a24 --- /dev/null +++ b/patches/rustc/0001-early-metadata.patch @@ -0,0 +1,1903 @@ +diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs +index 210f04a11..51330df4e 100644 +--- a/compiler/rustc_driver_impl/src/lib.rs ++++ b/compiler/rustc_driver_impl/src/lib.rs +@@ -313,6 +313,8 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send)) + return None; + } + ++ let early_metadata = passes::write_early_metadata(tcx); ++ + tcx.ensure_ok().analysis(()); + + if callbacks.after_analysis(compiler, tcx) == Compilation::Stop { +@@ -333,12 +335,15 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send)) + + tcx.report_unused_features(); + +- Some(linker) ++ Some((linker, early_metadata.into_path())) + }); + + // Linking is done outside the `compiler.enter()` so that the + // `GlobalCtxt` within `Queries` can be freed as early as possible. +- if let (Some(linker), incr_comp_session) = linker { ++ if let (Some((linker, early_metadata)), incr_comp_session) = linker { ++ // Linking finishes code generation; if it fails, withdraw the ++ // early metadata too. ++ let _early_metadata = passes::EarlyMetadata::new(sess, early_metadata); + linker.link(sess, incr_comp_session, codegen_backend); + } + }) +diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs +index dbbf06818..7a54d9683 100644 +--- a/compiler/rustc_hir_analysis/src/lib.rs ++++ b/compiler/rustc_hir_analysis/src/lib.rs +@@ -145,7 +145,14 @@ pub fn provide(providers: &mut Providers) { + + pub fn check_crate(tcx: TyCtxt<'_>) { + let _prof_timer = tcx.sess.timer("type_check_crate"); ++ check_crate_interfaces(tcx); ++ check_crate_bodies(tcx); ++} + ++/// The part of [`check_crate`] that checks item interfaces (well-formedness, ++/// coherence) without type-checking function bodies. Metadata written after ++/// this describes the crate's interface (`-Zearly-metadata`). ++pub fn check_crate_interfaces(tcx: TyCtxt<'_>) { + tcx.sess.time("coherence_checking", || { + // When discarding query call results, use an explicit type to indicate + // what we are intending to discard, to help future type-based refactoring. +@@ -160,7 +167,11 @@ pub fn check_crate(tcx: TyCtxt<'_>) { + let _: R = tcx.ensure_result().crate_inherent_impls_validity_check(()); + let _: R = tcx.ensure_result().crate_inherent_impls_overlap_check(()); + }); ++} + ++/// The part of [`check_crate`] after [`check_crate_interfaces`]: evaluates ++/// statics and consts, and type-checks every body. ++pub fn check_crate_bodies(tcx: TyCtxt<'_>) { + tcx.par_hir_body_owners(|item_def_id| { + let def_kind = tcx.def_kind(item_def_id); + // Make sure we evaluate all static and (non-associated) const items, even if unused. +diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs +index da0ebce5b..621bab9f0 100644 +--- a/compiler/rustc_interface/src/passes.rs ++++ b/compiler/rustc_interface/src/passes.rs +@@ -892,6 +892,7 @@ pub fn write_interface<'tcx>(tcx: TyCtxt<'tcx>) { + + pub static DEFAULT_QUERY_PROVIDERS: LazyLock = LazyLock::new(|| { + let providers = &mut Providers::default(); ++ providers.queries.analysis_interfaces = analysis_interfaces; + providers.queries.analysis = analysis; + providers.queries.resolver_for_lowering_raw = resolver_for_lowering_raw; + providers.queries.stripped_cfg_items = |tcx, _| &tcx.resolutions(()).stripped_cfg_items[..]; +@@ -1088,9 +1089,9 @@ pub fn emit_delayed_lints(tcx: TyCtxt<'_>) { + } + } + +-/// Runs all analyses that we guarantee to run, even if errors were reported in earlier analyses. +-/// This function never fails. +-fn run_required_analyses(tcx: TyCtxt<'_>) { ++/// Runs the required analyses up to and including the item interface checks, ++/// before any function body is type-checked. See the `analysis_interfaces` query. ++fn analysis_interfaces(tcx: TyCtxt<'_>, (): ()) { + if tcx.sess.opts.unstable_opts.input_stats { + rustc_passes::input_stats::print_hir_stats(tcx); + } +@@ -1143,7 +1144,16 @@ fn run_required_analyses(tcx: TyCtxt<'_>) { + emit_delayed_lints(tcx); + }); + +- rustc_hir_analysis::check_crate(tcx); ++ let _prof_timer = tcx.sess.timer("type_check_crate_interfaces"); ++ rustc_hir_analysis::check_crate_interfaces(tcx); ++} ++ ++/// Runs all analyses that we guarantee to run, even if errors were reported in earlier analyses. ++/// This function never fails. ++fn run_required_analyses(tcx: TyCtxt<'_>) { ++ let sess = tcx.sess; ++ tcx.ensure_ok().analysis_interfaces(()); ++ sess.time("type_check_crate_bodies", || rustc_hir_analysis::check_crate_bodies(tcx)); + // Freeze definitions as we don't add new ones at this point. + // We need to wait until now since we synthesize a by-move body + // for all coroutine-closures. +@@ -1281,6 +1291,79 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) { + } + } + ++/// Early metadata written by [`write_early_metadata`]. If the compilation ++/// fails (reports errors, or panics) while this is alive, the early metadata ++/// is deleted: a promise withdrawn, which tells dependents waiting for the ++/// crate's full metadata that it won't come. ++#[must_use] ++pub struct EarlyMetadata<'a> { ++ sess: &'a Session, ++ path: Option, ++} ++ ++impl<'a> EarlyMetadata<'a> { ++ /// Guards the early metadata at `path`, if any, for the rest of `sess`'s ++ /// compilation: linking finishes code generation and writes the rlib ++ /// after the global context is gone. ++ pub fn new(sess: &'a Session, path: Option) -> Self { ++ EarlyMetadata { sess, path } ++ } ++ ++ /// Stops guarding the early metadata, and returns its path, to be ++ /// guarded again with [`EarlyMetadata::new`]. ++ pub fn into_path(mut self) -> Option { ++ self.path.take() ++ } ++} ++ ++impl Drop for EarlyMetadata<'_> { ++ fn drop(&mut self) { ++ if let Some(path) = &self.path ++ && (std::thread::panicking() || self.sess.dcx().has_errors().is_some()) ++ { ++ let _ = std::fs::remove_file(path); ++ } ++ } ++} ++ ++/// `-Zearly-metadata`: once the crate's item interfaces are checked, and ++/// before its function bodies are, write early metadata (and announce it with ++/// `--json=artifacts`) so a build tool can start dependent crates. Whatever ++/// the interface needs from a body (an opaque type's hidden type, a const's ++/// value) is computed on demand. Full metadata is written as usual later. If a ++/// body fails to check, compilation still fails, and the early metadata is ++/// withdrawn; see [`EarlyMetadata`]. ++pub fn write_early_metadata(tcx: TyCtxt<'_>) -> EarlyMetadata<'_> { ++ let none = EarlyMetadata { sess: tcx.sess, path: None }; ++ // Crates nothing can depend on (binaries) write no early metadata. ++ if !tcx.sess.opts.unstable_opts.early_metadata ++ || !tcx.sess.opts.output_types.contains_key(&OutputType::Metadata) ++ || !tcx.needs_metadata() ++ { ++ return none; ++ } ++ tcx.ensure_ok().analysis_interfaces(()); ++ if tcx.sess.dcx().has_errors_or_delayed_bugs().is_some() { ++ return none; ++ } ++ // Encoding freezes the definitions table, so first create the ++ // definitions that checking bodies adds: statics' nested allocations and ++ // async closures' by-move bodies. This checks those bodies now, the way ++ // `check_crate_bodies` would (in parallel under `-Zthreads`). ++ tcx.par_hir_body_owners(|def_id| { ++ if let rustc_hir::def::DefKind::Static { .. } = tcx.def_kind(def_id) { ++ tcx.ensure_ok().eval_static_initializer(def_id); ++ } ++ if tcx.needs_coroutine_by_move_body_def_id(def_id.to_def_id()) { ++ tcx.ensure_done().coroutine_by_move_body_def_id(def_id); ++ } ++ }); ++ if tcx.sess.dcx().has_errors_or_delayed_bugs().is_some() { ++ return none; ++ } ++ EarlyMetadata { sess: tcx.sess, path: rustc_metadata::fs::encode_and_write_early_metadata(tcx) } ++} ++ + /// Runs the codegen backend, after which the AST and analysis can + /// be discarded. + pub(crate) fn start_codegen<'tcx>( +@@ -1311,6 +1394,23 @@ pub(crate) fn start_codegen<'tcx>( + + info!("Pre-codegen\n{:?}", tcx.debug_stats()); + ++ // `-Zearly-metadata`: code generation needs the full metadata of ++ // dependencies that were loaded from early metadata. ++ if tcx.sess.opts.output_types.should_codegen() { ++ CStore::load_full_metadata(tcx); ++ // Cross-crate LTO reads dependencies' rlibs during code generation, ++ // not just when linking. ++ if matches!( ++ tcx.sess.lto(), ++ rustc_session::config::Lto::Fat | rustc_session::config::Lto::Thin ++ ) { ++ CStore::wait_for_rlibs( ++ tcx.sess, ++ tcx.crates(()).iter().map(|&cnum| &**tcx.used_crate_source(cnum)), ++ ); ++ } ++ } ++ + let metadata = match rustc_metadata::fs::encode_and_write_metadata(tcx) { + Ok(metadata) => metadata, + Err(guar) => guar.raise_fatal(), +diff --git a/compiler/rustc_interface/src/queries.rs b/compiler/rustc_interface/src/queries.rs +index 759297bc6..ae0153678 100644 +--- a/compiler/rustc_interface/src/queries.rs ++++ b/compiler/rustc_interface/src/queries.rs +@@ -164,6 +164,15 @@ pub fn link( + return; + } + ++ // `-Zearly-metadata`: dependencies' rlibs may still be being written. ++ rustc_metadata::creader::CStore::wait_for_rlibs( ++ sess, ++ self.crate_info ++ .used_crates ++ .iter() ++ .map(|cnum| &*self.crate_info.used_crate_source[cnum]), ++ ); ++ + let _timer = sess.prof.verbose_generic_activity("link_crate"); + let _timing = sess.timings.section_guard(sess.dcx(), TimingSection::Linking); + codegen_backend.link( +diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs +index aea843ac0..b1eed4433 100644 +--- a/compiler/rustc_metadata/src/creader.rs ++++ b/compiler/rustc_metadata/src/creader.rs +@@ -1,7 +1,7 @@ + //! Validates all used crates and extern libraries and loads their metadata + + use std::collections::BTreeMap; +-use std::path::Path; ++use std::path::{Path, PathBuf}; + use std::str::FromStr; + use std::{cmp, env, iter}; + +@@ -235,7 +235,12 @@ pub fn has_crate_data(&self, cnum: CrateNum) -> bool { + } + + pub(crate) fn get_crate_data(&self, cnum: CrateNum) -> &CrateMetadata { +- self.metas[cnum].as_ref().unwrap_or_else(|| panic!("Failed to get crate data for {cnum:?}")) ++ let data = self.metas[cnum] ++ .as_ref() ++ .unwrap_or_else(|| panic!("Failed to get crate data for {cnum:?}")); ++ // A crate loaded from early metadata is decoded from its full metadata ++ // once that's loaded. ++ data.full().unwrap_or(data) + } + + pub(crate) fn get_crate_data_mut(&mut self, cnum: CrateNum) -> &mut CrateMetadata { +@@ -265,9 +270,62 @@ pub fn resolved_extern_crate(&self, externs_name: Symbol) -> Option { + } + + pub(crate) fn iter_crate_data(&self) -> impl Iterator { +- self.metas ++ self.metas.iter_enumerated().filter_map(|(cnum, data)| { ++ data.as_deref().map(|data| (cnum, data.full().unwrap_or(data))) ++ }) ++ } ++ ++ /// `-Zearly-metadata`: loads the full metadata of every dependency loaded ++ /// from early metadata. Code generation needs it: the MIR of generic and ++ /// inline functions, exported symbols. Full metadata that isn't written ++ /// yet is waited for (see [`wait_for_full_metadata`]). ++ pub fn load_full_metadata(tcx: TyCtxt<'_>) { ++ let cstore = CStore::from_tcx(tcx); ++ let early: Vec = cstore ++ .metas + .iter_enumerated() + .filter_map(|(cnum, data)| data.as_deref().map(|data| (cnum, data))) ++ .filter(|(_, data)| data.is_early() && data.full().is_none()) ++ .map(|(cnum, _)| cnum) ++ .collect(); ++ let mut pause = Pause::default(); ++ for cnum in early { ++ let data = cstore.metas[cnum].as_deref().unwrap(); ++ let early_path = data.source().rmeta.clone().unwrap(); ++ let (blob, full_path) = wait_for_full_metadata( ++ tcx, ++ &*cstore.metadata_loader, ++ &early_path, ++ data.hash(), ++ &mut pause, ++ ); ++ data.set_full(tcx, blob, full_path); ++ } ++ pause.resume(tcx.sess); ++ } ++ ++ /// `-Zearly-metadata`: waits until the rlibs this crate links against ++ /// exist. A crate that links can start on its dependencies' metadata; the ++ /// locator then records where each dependency's rlib will be, and the ++ /// rlib is written (atomically) when that dependency finishes. Fails if a ++ /// dependency's early metadata is retracted first: it failed to compile. ++ pub fn wait_for_rlibs<'a>(sess: &Session, sources: impl IntoIterator) { ++ let mut pause = Pause::default(); ++ for source in sources { ++ let Some(rlib) = &source.rlib else { continue }; ++ let early = rlib.with_extension(crate::fs::EARLY_METADATA_EXTENSION); ++ while !rlib.exists() { ++ if !early.exists() { ++ sess.dcx().fatal(format!( ++ "a dependency failed to compile, or its rlib `{}` is missing", ++ rlib.display() ++ )); ++ } ++ pause.pause(sess, rlib); ++ std::thread::sleep(std::time::Duration::from_millis(10)); ++ } ++ } ++ pause.resume(sess); + } + + pub fn all_proc_macro_def_ids(&self, tcx: TyCtxt<'_>) -> impl Iterator { +@@ -1425,3 +1483,81 @@ fn visit_item(&mut self, item: &'ast ast::Item) { + visit::walk_crate(&mut f, krate); + f.spans + } ++ ++/// While this compilation waits for dependencies' full metadata or rlibs, it ++/// tells the build tool, announcing each file it waits for in turn (a ++/// `wait-metadata` artifact notification) and when it continues (`resume`). ++/// The build tool can give its job slot to other work meanwhile. It resumes ++/// as soon as the file is written, without taking a jobserver token, so it ++/// can't be starved by work started in its place: the build tool counts it ++/// as running again and starts nothing new until enough jobs finish. This ++/// never touches the jobserver. ++#[derive(Default)] ++struct Pause { ++ paused: bool, ++ /// The file announced last: a paused compilation can wait for several ++ /// files in turn, and announces each, so the build tool knows when it's ++ /// really ready to resume. ++ waiting_for: Option, ++} ++ ++impl Pause { ++ fn pause(&mut self, sess: &Session, waiting_for: &Path) { ++ if self.waiting_for.as_deref() == Some(waiting_for) { ++ return; ++ } ++ self.paused = true; ++ self.waiting_for = Some(waiting_for.to_path_buf()); ++ if sess.opts.json_artifact_notifications { ++ sess.dcx().emit_artifact_notification(waiting_for, "wait-metadata"); ++ } ++ } ++ ++ fn resume(&mut self, sess: &Session) { ++ if !self.paused { ++ return; ++ } ++ self.paused = false; ++ self.waiting_for = None; ++ if sess.opts.json_artifact_notifications { ++ sess.dcx().emit_artifact_notification(Path::new(""), "resume"); ++ } ++ } ++} ++ ++/// Waits until the full metadata of the crate whose early metadata is at ++/// `early_path` is written, with the same crate hash. Fails if the early ++/// metadata is retracted (deleted) first: the crate failed to compile, so its ++/// full metadata will never come. The compiler retracts it on errors, and a ++/// build tool can retract it if the compiler crashes. ++fn wait_for_full_metadata( ++ tcx: TyCtxt<'_>, ++ metadata_loader: &dyn MetadataLoader, ++ early_path: &Path, ++ hash: Svh, ++ pause: &mut Pause, ++) -> (MetadataBlob, PathBuf) { ++ let full_path = crate::locator::full_metadata_path(early_path); ++ loop { ++ // A file with another hash is stale, and will be replaced. ++ if let Ok(blob) = crate::locator::get_metadata_section( ++ &tcx.sess.target, ++ crate::locator::CrateFlavor::Rmeta, ++ &full_path, ++ metadata_loader, ++ tcx.sess.cfg_version, ++ None, ++ ) && blob.get_crate_hash() == hash ++ { ++ return (blob, full_path); ++ } ++ if !early_path.exists() { ++ tcx.dcx().fatal(format!( ++ "a dependency failed to compile after writing early metadata `{}`", ++ early_path.display() ++ )); ++ } ++ pause.pause(tcx.sess, &full_path); ++ std::thread::sleep(std::time::Duration::from_millis(10)); ++ } ++} +diff --git a/compiler/rustc_metadata/src/fs.rs b/compiler/rustc_metadata/src/fs.rs +index ed177708f..b7d484afb 100644 +--- a/compiler/rustc_metadata/src/fs.rs ++++ b/compiler/rustc_metadata/src/fs.rs +@@ -14,7 +14,7 @@ + BinaryOutputToTty, FailedCopyToStdout, FailedCreateEncodedMetadata, FailedCreateFile, + FailedCreateTempdir, FailedWriteError, + }; +-use crate::{EncodedMetadata, encode_metadata}; ++use crate::{EncodedMetadata, encode_early_metadata, encode_metadata}; + + // FIXME(eddyb) maybe include the crate name in this? + pub const METADATA_FILENAME: &str = "lib.rmeta"; +@@ -117,6 +117,52 @@ pub fn encode_and_write_metadata(tcx: TyCtxt<'_>) -> Result PathBuf { ++ rmeta.with_extension(EARLY_METADATA_EXTENSION) ++} ++ ++pub const EARLY_METADATA_EXTENSION: &str = "early-rmeta"; ++ ++/// Writes early metadata (`-Zearly-metadata`) next to where the full metadata ++/// will go, and announces it with an `early-metadata` artifact notification. ++/// Returns where it was written. ++/// ++/// Full metadata and an rlib left over from an earlier compilation are deleted ++/// first, so that from here on, one that exists is this compilation's: ++/// dependents started on the early metadata can simply wait for it to ++/// appear. ++pub fn encode_and_write_early_metadata(tcx: TyCtxt<'_>) -> Option { ++ let OutFileName::Real(out_filename) = filename_for_metadata(tcx.sess, tcx.output_filenames(())) ++ else { ++ return None; ++ }; ++ let _ = fs::remove_file(&out_filename); ++ if tcx.crate_types().contains(&CrateType::Rlib) { ++ let _ = fs::remove_file(out_filename.with_extension("rlib")); ++ } ++ let early_filename = early_metadata_path(&out_filename); ++ // Written elsewhere and renamed into place, as for full metadata. ++ let metadata_tmpdir = TempDirBuilder::new() ++ .prefix("rmeta") ++ .tempdir_in(out_filename.parent().unwrap_or_else(|| Path::new(""))) ++ .unwrap_or_else(|err| tcx.dcx().emit_fatal(FailedCreateTempdir { err })); ++ let metadata_tmpdir = MaybeTempDir::new(metadata_tmpdir, tcx.sess.opts.cg.save_temps); ++ let tmp_filename = metadata_tmpdir.as_ref().join("early.rmeta"); ++ encode_early_metadata(tcx, &tmp_filename); ++ if tcx.sess.dcx().has_errors_or_delayed_bugs().is_some() { ++ return None; ++ } ++ if let Err(err) = non_durable_rename(&tmp_filename, &early_filename) { ++ tcx.dcx().emit_fatal(FailedWriteError { filename: early_filename, err }); ++ } ++ if tcx.sess.opts.json_artifact_notifications { ++ tcx.dcx().emit_artifact_notification(&early_filename, "early-metadata"); ++ } ++ Some(early_filename) ++} ++ + #[cfg(not(target_os = "linux"))] + pub fn non_durable_rename(src: &Path, dst: &Path) -> std::io::Result<()> { + std::fs::rename(src, dst) +diff --git a/compiler/rustc_metadata/src/lib.rs b/compiler/rustc_metadata/src/lib.rs +index dd963fc87..a5065a32c 100644 +--- a/compiler/rustc_metadata/src/lib.rs ++++ b/compiler/rustc_metadata/src/lib.rs +@@ -27,4 +27,7 @@ + + pub use fs::{METADATA_FILENAME, emit_wrapper_file}; + pub use host_dylib::{DylibError, load_symbol_from_dylib}; +-pub use rmeta::{EncodedMetadata, METADATA_HEADER, ProcMacroKind, encode_metadata, rendered_const}; ++pub use rmeta::{ ++ EncodedMetadata, METADATA_HEADER, ProcMacroKind, encode_early_metadata, encode_metadata, ++ rendered_const, ++}; +diff --git a/compiler/rustc_metadata/src/locator.rs b/compiler/rustc_metadata/src/locator.rs +index 38da6561e..a5bc2c4e1 100644 +--- a/compiler/rustc_metadata/src/locator.rs ++++ b/compiler/rustc_metadata/src/locator.rs +@@ -237,6 +237,7 @@ + + use crate::creader::{Library, MetadataLoader}; + use crate::diagnostics; ++use crate::fs::{EARLY_METADATA_EXTENSION, early_metadata_path}; + use crate::rmeta::{METADATA_HEADER, MetadataBlob, ProcMacroKind, rustc_version}; + + #[derive(Clone)] +@@ -256,6 +257,10 @@ pub(crate) struct CrateLocator<'a> { + filesearch: &'a FileSearch, + is_proc_macro: bool, + path_kind: PathKind, ++ /// `-Zearly-metadata`: a crate may also be loaded from early metadata ++ /// (`.early-rmeta`), written before its full metadata. See ++ /// [`CrateLocator::choose_metadata`]. ++ accept_early_metadata: bool, + } + + #[derive(Clone, Debug)] +@@ -341,6 +346,7 @@ pub(crate) fn new( + filesearch: sess.target_filesearch(), + path_kind, + is_proc_macro: false, ++ accept_early_metadata: sess.opts.unstable_opts.early_metadata, + } + } + +@@ -431,12 +437,21 @@ fn find_library_crate( + // option and thus can be anything, and the incorrect match will be + // handled safely in `extract_one`. + let mut should_check_staticlibs = true; ++ let early_rmeta_suffix = &format!(".{EARLY_METADATA_EXTENSION}"); ++ let early_rmeta = self.accept_early_metadata.then_some(( ++ rmeta_prefix.as_str(), ++ early_rmeta_suffix.as_str(), ++ CrateFlavor::Rmeta, ++ )); + for (prefix, suffix, kind) in [ + (rlib_prefix.as_str(), rlib_suffix, CrateFlavor::Rlib), + (rmeta_prefix.as_str(), rmeta_suffix, CrateFlavor::Rmeta), + (dylib_prefix, dylib_suffix, CrateFlavor::Dylib), + (interface_prefix, interface_suffix, CrateFlavor::SDylib), +- ] { ++ ] ++ .into_iter() ++ .chain(early_rmeta) ++ { + if prefix == staticlib_prefix && suffix == staticlib_suffix { + should_check_staticlibs = false; + } +@@ -528,6 +543,23 @@ fn extract_lib( + interfaces: FxIndexSet, + ) -> Result, CrateError> { + let mut slot = None; ++ // Of a crate's early and full metadata, prefer the full metadata if ++ // it exists: writing early metadata deletes any older full metadata. ++ let rmetas = if self.accept_early_metadata { ++ let early: Vec = ++ rmetas.iter().filter(|path| is_early_metadata(path)).cloned().collect(); ++ let mut rmetas = rmetas; ++ for early in early { ++ let full = full_metadata_path(&early); ++ if rmetas.contains(&full) { ++ let chosen = self.choose_metadata(&full, &early); ++ rmetas.shift_remove(if chosen == full { &early } else { &full }); ++ } ++ } ++ rmetas ++ } else { ++ rmetas ++ }; + // Order here matters, rmeta should come first. + // + // Make sure there's at most one rlib and at most one dylib. +@@ -543,10 +575,38 @@ fn extract_lib( + return Err(CrateError::FullMetadataNotFound(self.crate_name, CrateFlavor::SDylib)); + } + ++ // `-Zearly-metadata`: a crate that links, started on a dependency's ++ // metadata, links against its rlib next to it, which may not be ++ // written yet. It waits for it before linking (see ++ // `CStore::wait_for_rlibs`). ++ let rlib = match (&rlib, &dylib, &rmeta) { ++ (None, None, Some(rmeta)) ++ if self.accept_early_metadata ++ && !self.only_needs_metadata ++ && !self.is_proc_macro => ++ { ++ let full = if is_early_metadata(rmeta) { ++ full_metadata_path(rmeta) ++ } else { ++ rmeta.clone() ++ }; ++ Some(full.with_extension("rlib")) ++ } ++ _ => rlib, ++ }; ++ + let source = CrateSource { rmeta, rlib, dylib, sdylib_interface }; + Ok(slot.map(|(svh, metadata, _, _)| (svh, Library { source, metadata }))) + } + ++ /// Of a crate's full and early metadata, the one to load: the full one ++ /// if it exists, otherwise the early one. Writing early metadata deletes ++ /// the crate's old full metadata, so a full file next to early metadata ++ /// is from the same or a later compilation, never an earlier one. ++ fn choose_metadata(&self, full: &Path, early: &Path) -> PathBuf { ++ if full.exists() || !early.exists() { full.to_path_buf() } else { early.to_path_buf() } ++ } ++ + fn needs_crate_flavor(&self, flavor: CrateFlavor) -> bool { + if flavor == CrateFlavor::Dylib && self.is_proc_macro { + return true; +@@ -752,6 +812,19 @@ fn find_commandline_library( + let mut dylibs = FxIndexSet::default(); + let mut sdylib_interfaces = FxIndexSet::default(); + for loc in &self.exact_paths { ++ // `--extern foo=libfoo.rmeta` also finds `libfoo.early-rmeta`, and ++ // loads the full metadata if it exists. ++ let early_loc; ++ let loc = if self.accept_early_metadata ++ && loc.original().extension().is_some_and(|ext| ext == "rmeta") ++ && self.choose_metadata(loc.original(), &early_metadata_path(loc.original())) ++ != *loc.original() ++ { ++ early_loc = CanonicalizedPath::new(early_metadata_path(loc.original())); ++ &early_loc ++ } else { ++ loc ++ }; + let loc_canon = loc.canonicalized(); + let loc_orig = loc.original(); + if !loc_canon.exists() { +@@ -774,7 +847,7 @@ fn find_commandline_library( + rlibs.insert(loc_canon.clone()); + continue; + } +- if file.ends_with(".rmeta") { ++ if file.ends_with(".rmeta") || is_early_metadata(loc_orig) { + rmetas.insert(loc_canon.clone()); + continue; + } +@@ -814,7 +887,7 @@ pub(crate) fn into_error( + } + } + +-fn get_metadata_section<'p>( ++pub(crate) fn get_metadata_section<'p>( + target: &Target, + flavor: CrateFlavor, + filename: &'p Path, +@@ -973,13 +1046,23 @@ fn get_flavor_from_path(path: &Path) -> CrateFlavor { + + if filename.ends_with(".rlib") { + CrateFlavor::Rlib +- } else if filename.ends_with(".rmeta") { ++ } else if filename.ends_with(".rmeta") || is_early_metadata(path) { + CrateFlavor::Rmeta + } else { + CrateFlavor::Dylib + } + } + ++/// Whether `path` is early metadata (`-Zearly-metadata`). ++pub(crate) fn is_early_metadata(path: &Path) -> bool { ++ path.extension().is_some_and(|ext| ext == EARLY_METADATA_EXTENSION) ++} ++ ++/// The full metadata of the crate whose early metadata is at `early`. ++pub(crate) fn full_metadata_path(early: &Path) -> PathBuf { ++ early.with_extension("rmeta") ++} ++ + /// A function to fetch all macros inside a proc-macro crate. + /// + /// Used by rust-analyzer-proc-macro-srv. +diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs +index 27b36c23d..1766fd77a 100644 +--- a/compiler/rustc_metadata/src/rmeta/decoder.rs ++++ b/compiler/rustc_metadata/src/rmeta/decoder.rs +@@ -149,6 +149,12 @@ pub(crate) struct CrateMetadata { + /// Information about the `extern crate` item or path that caused this crate to be loaded. + /// If this is `None`, then the crate was injected (e.g., by the allocator). + extern_crate: Option, ++ ++ /// `-Zearly-metadata`: if this crate was loaded from early metadata, its ++ /// full metadata once loaded (see `CStore::load_full_metadata`), which the ++ /// crate store hands out in place of this from then on. This stays alive, ++ /// so anything decoded from it stays valid. ++ full: OnceLock>, + } + + /// Holds information about a rustc_span::SourceFile imported from another crate. +@@ -1995,6 +2001,7 @@ pub(crate) fn new( + extern_crate: None, + hygiene_context: Default::default(), + def_key_cache: Default::default(), ++ full: OnceLock::new(), + }; + + cdata.incoherent_impls = cdata +@@ -2009,6 +2016,48 @@ pub(crate) fn new( + cdata + } + ++ /// Whether this crate was loaded from early metadata (`-Zearly-metadata`). ++ pub(crate) fn is_early(&self) -> bool { ++ self.source.rmeta.as_deref().is_some_and(crate::locator::is_early_metadata) ++ } ++ ++ /// The full metadata that replaced this early metadata, if loaded. ++ pub(crate) fn full(&self) -> Option<&CrateMetadata> { ++ self.full.get().map(|full| &**full) ++ } ++ ++ /// Replaces this early metadata with `blob`, the same crate's full ++ /// metadata at `path`, keeping what this session decided while loading it. ++ pub(crate) fn set_full(&self, tcx: TyCtxt<'_>, blob: MetadataBlob, path: PathBuf) { ++ let root = blob.get_root(); ++ let unhashed = blob.get_root_unhashed(); ++ let source = CrateSource { rmeta: Some(path), ..(*self.source).clone() }; ++ let mut full = CrateMetadata::new( ++ tcx, ++ blob, ++ root, ++ unhashed, ++ self.raw_proc_macros, ++ self.cnum, ++ self.cnum_map.clone(), ++ self.dep_kind, ++ source, ++ self.private_dep, ++ self.host_hash, ++ ); ++ full.used = self.used; ++ full.extern_crate = self.extern_crate.clone(); ++ // Source files are imported again from the full metadata's table: an ++ // imported file records its index in the table it came from. Spans ++ // decoded before this keep pointing at the early imports, which stay. ++ // Types decoded through a shorthand are cached by their position in ++ // the blob, which means something else in the full metadata. ++ // (Removing entries doesn't depend on the map's iteration order.) ++ #[allow(rustc::potential_query_instability)] ++ tcx.caches.ty_rcache.borrow_mut().retain(|key, _| key.cnum != Some(self.cnum)); ++ assert!(self.full.set(Box::new(full)).is_ok(), "full metadata loaded twice"); ++ } ++ + pub(crate) fn dependencies(&self) -> impl Iterator { + self.cnum_map.iter().copied() + } +diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs +index 154cf4f06..04b6e3616 100644 +--- a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs ++++ b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs +@@ -94,6 +94,28 @@ fn process_decoded(self, _tcx: TyCtxt<'_>, _err: impl Fn() -> !) -> Option, krate: CrateNum, query: &str) { ++ eprintln!( ++ "early-metadata-verify: `{query}` of `{}` answered from early metadata", ++ tcx.crate_name(krate) ++ ); ++} ++ + macro_rules! provide_one { + ($tcx:ident, $def_id:ident, $other:ident, $cdata:ident, $name:ident => { table }) => { + provide_one! { +@@ -156,6 +178,12 @@ fn $name<'tcx>( + + let cstore = CStore::from_tcx($tcx); + let $cdata = cstore.get_crate_data($def_id.krate); ++ if $tcx.sess.opts.unstable_opts.early_metadata_verify ++ && $cdata.is_early() ++ && FULL_METADATA_QUERIES.contains(&stringify!($name)) ++ { ++ verify_not_early($tcx, $def_id.krate, stringify!($name)); ++ } + + $compute + } +@@ -329,7 +357,13 @@ fn into_args(self) -> (DefId, SimplifiedType) { + associated_item => { cdata.get_associated_item(tcx, def_id.index) } + inherent_impls => { cdata.get_inherent_implementations_for_type(tcx, def_id.index) } + attrs_for_def => { tcx.arena.alloc_from_iter(cdata.get_item_attrs(tcx, def_id.index)) } +- is_mir_available => { cdata.is_item_mir_available(def_id.index) } ++ is_mir_available => { ++ let available = cdata.is_item_mir_available(def_id.index); ++ if !available && tcx.sess.opts.unstable_opts.early_metadata_verify && cdata.is_early() { ++ verify_not_early(tcx, def_id.krate, "is_mir_available"); ++ } ++ available ++ } + cross_crate_inlinable => { table_direct } + + dylib_dependency_formats => { cdata.get_dylib_dependency_formats(tcx) } +diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs +index afa5646be..8622dafd3 100644 +--- a/compiler/rustc_metadata/src/rmeta/encoder.rs ++++ b/compiler/rustc_metadata/src/rmeta/encoder.rs +@@ -10,7 +10,7 @@ + + use rustc_attr_ir::{AttributeKind, EncodeCrossCrate, find_attr}; + use rustc_data_structures::fingerprint::Fingerprint; +-use rustc_data_structures::fx::{FxIndexMap, FxIndexSet}; ++use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet}; + use rustc_data_structures::memmap::{Mmap, MmapMut}; + use rustc_data_structures::owned_slice::slice_owned; + use rustc_data_structures::stable_hash::{StableHash, StableHasher}; +@@ -78,6 +78,16 @@ pub(super) struct EncodeContext<'a, 'tcx> { + hygiene_ctxt: Rc>, + // Used for both `Symbol`s and `ByteSymbol`s. + symbol_index_table: FxHashMap, ++ ++ /// Whether this is early metadata (`-Zearly-metadata`), encoded after the ++ /// crate's item interfaces are checked and before its bodies are. ++ early: bool, ++ // Early metadata: the bodies the crate's interface needs (see ++ // `interface_bodies`), and the MIR and definitions nested in other ++ // bodies, which are left out. ++ interface_bodies: Option>, ++ deferred_mir: Vec<(LocalDefId, LocalDefId, bool, bool)>, ++ deferred_defs: Vec<(LocalDefId, LocalDefId)>, + } + + /// If the current crate is a proc-macro, returns early with `LazyArray::default()`. +@@ -522,7 +532,11 @@ fn encode_symbol_or_byte_symbol( + } + + fn encode_def_path_table(&mut self) { +- let defs = self.tcx.definitions(); ++ let defs = if self.early { ++ self.tcx.definitions_after_interfaces() ++ } else { ++ self.tcx.definitions() ++ }; + if self.is_proc_macro { + for def_id in std::iter::once(CRATE_DEF_ID) + .chain(self.tcx.resolutions(()).proc_macros.iter().copied()) +@@ -711,13 +725,20 @@ macro_rules! stat { + stat!("exportable-items", || self.encode_stable_order_of_exportable_impls()); + + // Encode exported symbols info. This is prefetched in `encode_metadata`. +- let (exported_non_generic_symbols, exported_generic_symbols) = ++ // Early metadata leaves them out: computing them collects the crate's ++ // monomorphizations, which needs its bodies and its dependencies' full ++ // metadata, and only code generation and linking read them, from full ++ // metadata. ++ let (exported_non_generic_symbols, exported_generic_symbols) = if self.early { ++ (LazyArray::default(), LazyArray::default()) ++ } else { + stat!("exported-symbols", || { + ( + self.encode_exported_symbols(tcx.exported_non_generic_symbols(LOCAL_CRATE)), + self.encode_exported_symbols(tcx.exported_generic_symbols(LOCAL_CRATE)), + ) +- }); ++ }) ++ }; + + // Encode the hygiene data. + // IMPORTANT: this *must* be the last thing that we encode (other than `SourceMap`). The +@@ -747,7 +768,13 @@ macro_rules! stat { + }, + + stable_crate_id: tcx.stable_crate_id(LOCAL_CRATE), +- required_panic_strategy: tcx.required_panic_strategy(LOCAL_CRATE), ++ // Computing this scans every body's MIR. Only linking reads it, ++ // from full metadata. ++ required_panic_strategy: if self.early { ++ None ++ } else { ++ tcx.required_panic_strategy(LOCAL_CRATE) ++ }, + panic_in_drop_strategy: tcx.sess.opts.unstable_opts.panic_in_drop, + edition: tcx.sess.edition(), + has_global_allocator: tcx.has_global_allocator(LOCAL_CRATE), +@@ -800,7 +827,17 @@ macro_rules! stat { + // By default the crate hash (SVH) is derived from the encoded metadata bytes. With + // `-Z metadata-crate-hash=no` we instead store the legacy HIR-based hash, which the + // `crate_hash` query computes directly without consulting `local_crate_hash`. +- let hash = if tcx.sess.opts.unstable_opts.metadata_crate_hash { ++ // With `-Zearly-metadata`, the crate hash is computed once, from the ++ // early metadata, and full metadata carries the same one: dependents ++ // that compiled against either file must agree on the crate's ++ // identity. It's still complete: the encoded bytes cover the ++ // interface (and every dependency's hash), and the supplement mixed ++ // into the hasher covers all HIR, bodies included, and the tracked ++ // options, the inputs full metadata is a function of. ++ let early_hash = if self.early { None } else { tcx.untracked().local_crate_hash.get() }; ++ let hash = if let Some(&early_hash) = early_hash { ++ early_hash ++ } else if tcx.sess.opts.unstable_opts.metadata_crate_hash { + self.opaque.flush(); + Svh::new(Fingerprint::from_le_bytes( + self.metadata_hasher.lock().unwrap().finish_128().to_le_bytes(), +@@ -808,7 +845,9 @@ macro_rules! stat { + } else { + tcx.crate_hash(LOCAL_CRATE) + }; +- tcx.untracked().local_crate_hash.set(hash).expect("local_crate_hash set twice"); ++ if early_hash.is_none() { ++ tcx.untracked().local_crate_hash.set(hash).unwrap(); ++ } + + let unhashed = stat!("final", || { + // Indexed by dependency `CrateNum`, matching the numbering `encode_crate_deps` uses. +@@ -1456,248 +1495,261 @@ fn encode_def_ids(&mut self) { + + let tcx = self.tcx; + +- for local_id in tcx.iter_local_def_id() { +- let def_id = local_id.to_def_id(); +- let def_kind = tcx.def_kind(local_id); +- self.tables.def_kind.set_some(def_id.index, def_kind); +- +- // The `DefCollector` will sometimes create unnecessary `DefId`s +- // for trivial const arguments which are directly lowered to +- // `ConstArgKind::Path`. We never actually access this `DefId` +- // anywhere so we don't need to encode it for other crates. +- // FIXME(mgca): This probably isn't true, they probably are accessed, but, test case? +- if def_kind == DefKind::AnonConst +- && matches!( +- tcx.hir_node_by_def_id(local_id), +- hir::Node::ConstArg(_) +- | hir::Node::Infer(hir::InferArg { kind: hir::InferArgKind::Const, .. }) +- ) +- { ++ let local_ids: Vec = if self.early { ++ tcx.iter_local_def_id_after_interfaces().collect() ++ } else { ++ tcx.iter_local_def_id().collect() ++ }; ++ for local_id in local_ids { ++ if let Some(body) = self.early_enclosing_body(local_id) { ++ self.tables.def_kind.set_some(local_id.local_def_index, tcx.def_kind(local_id)); ++ self.deferred_defs.push((local_id, body)); + continue; + } ++ self.encode_def_id(local_id); ++ } ++ self.encode_deferred(); + +- if def_kind == DefKind::Field +- && let hir::Node::Field(field) = tcx.hir_node_by_def_id(local_id) +- && let Some(anon) = field.default +- { +- record!(self.tables.default_fields[def_id] <- anon.def_id.to_def_id()); +- } ++ for (def_id, impls) in &tcx.crate_inherent_impls(()).0.inherent_impls { ++ record_defaulted_array!(self.tables.inherent_impls[def_id.to_def_id()] <- impls.iter().map(|def_id| { ++ assert!(def_id.is_local()); ++ def_id.index ++ })); ++ } + +- if should_encode_span(def_kind) { +- let def_span = tcx.def_span(local_id); +- record!(self.tables.def_span[def_id] <- def_span); +- } +- if should_encode_attrs(def_kind) { +- self.encode_attrs(local_id); +- } +- if should_encode_expn_that_defined(def_kind) { +- record!(self.tables.expn_that_defined[def_id] <- self.tcx.expn_that_defined(def_id)); +- } +- if should_encode_span(def_kind) +- && let Some(ident_span) = tcx.def_ident_span(def_id) +- { +- record!(self.tables.def_ident_span[def_id] <- ident_span); +- } +- if def_kind.has_codegen_attrs() { +- record!(self.tables.codegen_fn_attrs[def_id] <- self.tcx.codegen_fn_attrs(def_id)); +- } +- if should_encode_visibility(def_kind) { +- let vis = self +- .tcx +- .local_visibility(local_id) +- .map_id(|mod_id| mod_id.to_local_def_id().local_def_index); +- record!(self.tables.visibility[def_id] <- vis); +- } +- if should_encode_stability(def_kind) { +- self.encode_stability(def_id); +- self.encode_const_stability(def_id); +- self.encode_default_body_stability(def_id); +- self.encode_deprecation(def_id); +- } +- if should_encode_variances(tcx, def_id, def_kind) { +- let v = self.tcx.variances_of(def_id); +- record_array!(self.tables.variances_of[def_id] <- v); +- } +- if should_encode_fn_sig(def_kind) { +- record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id)); +- } +- if should_encode_generics(def_kind) { +- let g = tcx.generics_of(def_id); +- record!(self.tables.generics_of[def_id] <- g); +- record!(self.tables.explicit_clauses_of[def_id] <- self.tcx.explicit_clauses_of(def_id)); +- let inferred_outlives = self.tcx.inferred_outlives_of(def_id); +- record_defaulted_array!(self.tables.inferred_outlives_of[def_id] <- inferred_outlives); +- +- for param in &g.own_params { +- if let ty::GenericParamDefKind::Const { has_default: true, .. } = param.kind { +- let default = self.tcx.const_param_default(param.def_id); +- record!(self.tables.const_param_default[param.def_id] <- default); +- } ++ for (def_id, res_map) in &tcx.resolutions(()).doc_link_resolutions { ++ record!(self.tables.doc_link_resolutions[def_id.to_def_id()] <- res_map); ++ } ++ ++ for (def_id, traits) in &tcx.resolutions(()).doc_link_traits_in_scope { ++ record_array!(self.tables.doc_link_traits_in_scope[def_id.to_def_id()] <- traits); ++ } ++ } ++ ++ fn encode_def_id(&mut self, local_id: LocalDefId) { ++ let tcx = self.tcx; ++ let def_id = local_id.to_def_id(); ++ let def_kind = tcx.def_kind(local_id); ++ self.tables.def_kind.set_some(def_id.index, def_kind); ++ ++ // The `DefCollector` will sometimes create unnecessary `DefId`s ++ // for trivial const arguments which are directly lowered to ++ // `ConstArgKind::Path`. We never actually access this `DefId` ++ // anywhere so we don't need to encode it for other crates. ++ // FIXME(mgca): This probably isn't true, they probably are accessed, but, test case? ++ if def_kind == DefKind::AnonConst ++ && matches!( ++ tcx.hir_node_by_def_id(local_id), ++ hir::Node::ConstArg(_) ++ | hir::Node::Infer(hir::InferArg { kind: hir::InferArgKind::Const, .. }) ++ ) ++ { ++ return; ++ } ++ ++ if def_kind == DefKind::Field ++ && let hir::Node::Field(field) = tcx.hir_node_by_def_id(local_id) ++ && let Some(anon) = field.default ++ { ++ record!(self.tables.default_fields[def_id] <- anon.def_id.to_def_id()); ++ } ++ ++ if should_encode_span(def_kind) { ++ let def_span = tcx.def_span(local_id); ++ record!(self.tables.def_span[def_id] <- def_span); ++ } ++ if should_encode_attrs(def_kind) { ++ self.encode_attrs(local_id); ++ } ++ if should_encode_expn_that_defined(def_kind) { ++ record!(self.tables.expn_that_defined[def_id] <- self.tcx.expn_that_defined(def_id)); ++ } ++ if should_encode_span(def_kind) ++ && let Some(ident_span) = tcx.def_ident_span(def_id) ++ { ++ record!(self.tables.def_ident_span[def_id] <- ident_span); ++ } ++ if def_kind.has_codegen_attrs() { ++ record!(self.tables.codegen_fn_attrs[def_id] <- self.tcx.codegen_fn_attrs(def_id)); ++ } ++ if should_encode_visibility(def_kind) { ++ let vis = self ++ .tcx ++ .local_visibility(local_id) ++ .map_id(|mod_id| mod_id.to_local_def_id().local_def_index); ++ record!(self.tables.visibility[def_id] <- vis); ++ } ++ if should_encode_stability(def_kind) { ++ self.encode_stability(def_id); ++ self.encode_const_stability(def_id); ++ self.encode_default_body_stability(def_id); ++ self.encode_deprecation(def_id); ++ } ++ if should_encode_variances(tcx, def_id, def_kind) { ++ let v = self.tcx.variances_of(def_id); ++ record_array!(self.tables.variances_of[def_id] <- v); ++ } ++ if should_encode_fn_sig(def_kind) { ++ record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id)); ++ } ++ if should_encode_generics(def_kind) { ++ let g = tcx.generics_of(def_id); ++ record!(self.tables.generics_of[def_id] <- g); ++ record!(self.tables.explicit_clauses_of[def_id] <- self.tcx.explicit_clauses_of(def_id)); ++ let inferred_outlives = self.tcx.inferred_outlives_of(def_id); ++ record_defaulted_array!(self.tables.inferred_outlives_of[def_id] <- inferred_outlives); ++ ++ for param in &g.own_params { ++ if let ty::GenericParamDefKind::Const { has_default: true, .. } = param.kind { ++ let default = self.tcx.const_param_default(param.def_id); ++ record!(self.tables.const_param_default[param.def_id] <- default); + } + } +- if tcx.is_conditionally_const(def_id) { +- record!(self.tables.const_conditions[def_id] <- self.tcx.const_conditions(def_id)); +- } +- if should_encode_type(tcx, local_id, def_kind) { +- record!(self.tables.type_of[def_id] <- self.tcx.type_of(def_id)); +- } +- if should_encode_constness(def_kind) { +- let constness = self.tcx.constness(def_id); +- self.tables.constness.set(def_id.index, constness); +- } +- if let DefKind::Fn | DefKind::AssocFn = def_kind { +- let asyncness = tcx.asyncness(def_id); +- self.tables.asyncness.set(def_id.index, asyncness); +- record_array!(self.tables.fn_arg_idents[def_id] <- tcx.fn_arg_idents(def_id)); +- } +- if let Some(name) = tcx.intrinsic(def_id) { +- record!(self.tables.intrinsic[def_id] <- name); +- } +- if let DefKind::TyParam | DefKind::Trait = def_kind { +- let default = self.tcx.object_lifetime_default(def_id); +- record!(self.tables.object_lifetime_default[def_id] <- default); +- } +- if let DefKind::Trait = def_kind { +- record!(self.tables.trait_def[def_id] <- self.tcx.trait_def(def_id)); +- record_defaulted_array!(self.tables.explicit_super_clauses_of[def_id] <- +- self.tcx.explicit_super_clauses_of(def_id).skip_binder()); +- record_defaulted_array!(self.tables.explicit_implied_clauses_of[def_id] <- +- self.tcx.explicit_implied_clauses_of(def_id).skip_binder()); +- let module_children = self.tcx.module_children_local(local_id); +- record_array!(self.tables.module_children_non_reexports[def_id] <- +- module_children.iter().map(|child| child.res.def_id().index)); +- if self.tcx.is_const_trait(def_id) { +- record_defaulted_array!(self.tables.explicit_implied_const_bounds[def_id] +- <- self.tcx.explicit_implied_const_bounds(def_id).skip_binder()); +- } ++ } ++ if tcx.is_conditionally_const(def_id) { ++ record!(self.tables.const_conditions[def_id] <- self.tcx.const_conditions(def_id)); ++ } ++ if should_encode_type(tcx, local_id, def_kind) { ++ record!(self.tables.type_of[def_id] <- self.tcx.type_of(def_id)); ++ } ++ if should_encode_constness(def_kind) { ++ let constness = self.tcx.constness(def_id); ++ self.tables.constness.set(def_id.index, constness); ++ } ++ if let DefKind::Fn | DefKind::AssocFn = def_kind { ++ let asyncness = tcx.asyncness(def_id); ++ self.tables.asyncness.set(def_id.index, asyncness); ++ record_array!(self.tables.fn_arg_idents[def_id] <- tcx.fn_arg_idents(def_id)); ++ } ++ if let Some(name) = tcx.intrinsic(def_id) { ++ record!(self.tables.intrinsic[def_id] <- name); ++ } ++ if let DefKind::TyParam | DefKind::Trait = def_kind { ++ let default = self.tcx.object_lifetime_default(def_id); ++ record!(self.tables.object_lifetime_default[def_id] <- default); ++ } ++ if let DefKind::Trait = def_kind { ++ record!(self.tables.trait_def[def_id] <- self.tcx.trait_def(def_id)); ++ record_defaulted_array!(self.tables.explicit_super_clauses_of[def_id] <- ++ self.tcx.explicit_super_clauses_of(def_id).skip_binder()); ++ record_defaulted_array!(self.tables.explicit_implied_clauses_of[def_id] <- ++ self.tcx.explicit_implied_clauses_of(def_id).skip_binder()); ++ let module_children = self.tcx.module_children_local(local_id); ++ record_array!(self.tables.module_children_non_reexports[def_id] <- ++ module_children.iter().map(|child| child.res.def_id().index)); ++ if self.tcx.is_const_trait(def_id) { ++ record_defaulted_array!(self.tables.explicit_implied_const_bounds[def_id] ++ <- self.tcx.explicit_implied_const_bounds(def_id).skip_binder()); + } +- if let DefKind::TraitAlias = def_kind { +- record!(self.tables.trait_def[def_id] <- self.tcx.trait_def(def_id)); +- record_defaulted_array!(self.tables.explicit_super_clauses_of[def_id] <- +- self.tcx.explicit_super_clauses_of(def_id).skip_binder()); +- record_defaulted_array!(self.tables.explicit_implied_clauses_of[def_id] <- +- self.tcx.explicit_implied_clauses_of(def_id).skip_binder()); ++ } ++ if let DefKind::TraitAlias = def_kind { ++ record!(self.tables.trait_def[def_id] <- self.tcx.trait_def(def_id)); ++ record_defaulted_array!(self.tables.explicit_super_clauses_of[def_id] <- ++ self.tcx.explicit_super_clauses_of(def_id).skip_binder()); ++ record_defaulted_array!(self.tables.explicit_implied_clauses_of[def_id] <- ++ self.tcx.explicit_implied_clauses_of(def_id).skip_binder()); ++ } ++ if let DefKind::Trait | DefKind::Impl { .. } = def_kind { ++ let associated_item_def_ids = self.tcx.associated_item_def_ids(def_id); ++ record_array!(self.tables.associated_item_or_field_def_ids[def_id] <- ++ associated_item_def_ids.iter().map(|&def_id| { ++ assert!(def_id.is_local()); ++ def_id.index ++ }) ++ ); ++ for &def_id in associated_item_def_ids { ++ self.encode_info_for_assoc_item(def_id); + } +- if let DefKind::Trait | DefKind::Impl { .. } = def_kind { +- let associated_item_def_ids = self.tcx.associated_item_def_ids(def_id); +- record_array!(self.tables.associated_item_or_field_def_ids[def_id] <- +- associated_item_def_ids.iter().map(|&def_id| { +- assert!(def_id.is_local()); +- def_id.index +- }) ++ } ++ if let DefKind::Closure | DefKind::SyntheticCoroutineBody = def_kind ++ && let Some(coroutine_kind) = self.tcx.coroutine_kind(def_id) ++ { ++ self.tables.coroutine_kind.set(def_id.index, Some(coroutine_kind)) ++ } ++ if def_kind == DefKind::Closure && tcx.type_of(def_id).skip_binder().is_coroutine_closure() ++ { ++ let coroutine_for_closure = self.tcx.coroutine_for_closure(def_id); ++ self.tables.coroutine_for_closure.set_some(def_id.index, coroutine_for_closure.into()); ++ ++ // If this async closure has a by-move body, record it too. ++ if tcx.needs_coroutine_by_move_body_def_id(coroutine_for_closure) { ++ self.tables.coroutine_by_move_body_def_id.set_some( ++ coroutine_for_closure.index, ++ self.tcx.coroutine_by_move_body_def_id(coroutine_for_closure).into(), + ); +- for &def_id in associated_item_def_ids { +- self.encode_info_for_assoc_item(def_id); +- } + } +- if let DefKind::Closure | DefKind::SyntheticCoroutineBody = def_kind +- && let Some(coroutine_kind) = self.tcx.coroutine_kind(def_id) +- { +- self.tables.coroutine_kind.set(def_id.index, Some(coroutine_kind)) +- } +- if def_kind == DefKind::Closure +- && tcx.type_of(def_id).skip_binder().is_coroutine_closure() +- { +- let coroutine_for_closure = self.tcx.coroutine_for_closure(def_id); +- self.tables +- .coroutine_for_closure +- .set_some(def_id.index, coroutine_for_closure.into()); +- +- // If this async closure has a by-move body, record it too. +- if tcx.needs_coroutine_by_move_body_def_id(coroutine_for_closure) { +- self.tables.coroutine_by_move_body_def_id.set_some( +- coroutine_for_closure.index, +- self.tcx.coroutine_by_move_body_def_id(coroutine_for_closure).into(), +- ); +- } +- } +- if let DefKind::Static { .. } = def_kind { +- if !self.tcx.is_foreign_item(def_id) { +- match self.tcx.eval_static_initializer(def_id) { +- Ok(data) => record!(self.tables.eval_static_initializer[def_id] <- data), +- Err(err) => match err { +- interpret::ErrorHandled::Reported(_, _) => { +- self.tcx.dcx().delayed_bug(format!( +- "eval_static_initializer returned an error in metadata emission" +- )); +- } +- interpret::ErrorHandled::TooGeneric(span) => { +- span_bug!(span, "generic static???"); +- } +- }, +- }; +- } +- } +- if let DefKind::Enum | DefKind::Struct | DefKind::Union = def_kind { +- self.encode_info_for_adt(local_id); ++ } ++ if let DefKind::Static { .. } = def_kind { ++ if !self.tcx.is_foreign_item(def_id) { ++ match self.tcx.eval_static_initializer(def_id) { ++ Ok(data) => record!(self.tables.eval_static_initializer[def_id] <- data), ++ Err(err) => match err { ++ interpret::ErrorHandled::Reported(_, _) => { ++ self.tcx.dcx().delayed_bug(format!( ++ "eval_static_initializer returned an error in metadata emission" ++ )); ++ } ++ interpret::ErrorHandled::TooGeneric(span) => { ++ span_bug!(span, "generic static???"); ++ } ++ }, ++ }; + } +- if let DefKind::Mod = def_kind { +- self.encode_info_for_mod(local_id); ++ } ++ if let DefKind::Enum | DefKind::Struct | DefKind::Union = def_kind { ++ self.encode_info_for_adt(local_id); ++ } ++ if let DefKind::Mod = def_kind { ++ self.encode_info_for_mod(local_id); ++ } ++ if let DefKind::Macro(_) = def_kind { ++ self.encode_info_for_macro(local_id); ++ } ++ if let DefKind::TyAlias = def_kind { ++ self.tables ++ .type_alias_is_checked ++ .set(def_id.index, self.tcx.type_alias_is_checked(def_id)); ++ if self.tcx.type_alias_is_checked(def_id) { ++ record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id)); + } +- if let DefKind::Macro(_) = def_kind { +- self.encode_info_for_macro(local_id); ++ } ++ if let DefKind::OpaqueTy = def_kind { ++ self.encode_explicit_item_bounds(def_id); ++ self.encode_explicit_item_self_bounds(def_id); ++ record!(self.tables.opaque_ty_origin[def_id] <- self.tcx.opaque_ty_origin(def_id)); ++ self.encode_precise_capturing_args(def_id); ++ if tcx.is_conditionally_const(def_id) { ++ record_defaulted_array!(self.tables.explicit_implied_const_bounds[def_id] ++ <- tcx.explicit_implied_const_bounds(def_id).skip_binder()); + } +- if let DefKind::TyAlias = def_kind { +- self.tables +- .type_alias_is_checked +- .set(def_id.index, self.tcx.type_alias_is_checked(def_id)); +- if self.tcx.type_alias_is_checked(def_id) { ++ record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id)); ++ } ++ if let DefKind::AssocTy = def_kind { ++ let assoc_item = tcx.associated_item(def_id); ++ match assoc_item.container { ++ ty::AssocContainer::Trait => { + record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id)); + } +- } +- if let DefKind::OpaqueTy = def_kind { +- self.encode_explicit_item_bounds(def_id); +- self.encode_explicit_item_self_bounds(def_id); +- record!(self.tables.opaque_ty_origin[def_id] <- self.tcx.opaque_ty_origin(def_id)); +- self.encode_precise_capturing_args(def_id); +- if tcx.is_conditionally_const(def_id) { +- record_defaulted_array!(self.tables.explicit_implied_const_bounds[def_id] +- <- tcx.explicit_implied_const_bounds(def_id).skip_binder()); +- } +- record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id)); +- } +- if let DefKind::AssocTy = def_kind { +- let assoc_item = tcx.associated_item(def_id); +- match assoc_item.container { +- ty::AssocContainer::Trait => { +- record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id)); +- } +- ty::AssocContainer::InherentImpl => { +- record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id)); +- } +- ty::AssocContainer::TraitImpl(_) => {} ++ ty::AssocContainer::InherentImpl => { ++ record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id)); + } +- } +- if let DefKind::AnonConst = def_kind { +- record!(self.tables.anon_const_kind[def_id] <- self.tcx.anon_const_kind(def_id)); +- } +- if let DefKind::Const | DefKind::AssocConst = def_kind { +- record!(self.tables.const_of_item[def_id] <- self.tcx.const_of_item(def_id)); +- } +- if tcx.impl_method_has_trait_impl_trait_tys(def_id) +- && let Ok(table) = self.tcx.collect_return_position_impl_trait_in_trait_tys(def_id) +- { +- record!(self.tables.collect_return_position_impl_trait_in_trait_tys[def_id] <- table); +- } +- if let DefKind::Impl { .. } | DefKind::Trait = def_kind { +- let table = tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id); +- record!(self.tables.associated_types_for_impl_traits_in_trait_or_impl[def_id] <- table); ++ ty::AssocContainer::TraitImpl(_) => {} + } + } +- +- for (def_id, impls) in &tcx.crate_inherent_impls(()).0.inherent_impls { +- record_defaulted_array!(self.tables.inherent_impls[def_id.to_def_id()] <- impls.iter().map(|def_id| { +- assert!(def_id.is_local()); +- def_id.index +- })); ++ if let DefKind::AnonConst = def_kind { ++ record!(self.tables.anon_const_kind[def_id] <- self.tcx.anon_const_kind(def_id)); + } +- +- for (def_id, res_map) in &tcx.resolutions(()).doc_link_resolutions { +- record!(self.tables.doc_link_resolutions[def_id.to_def_id()] <- res_map); ++ if let DefKind::Const | DefKind::AssocConst = def_kind { ++ record!(self.tables.const_of_item[def_id] <- self.tcx.const_of_item(def_id)); + } +- +- for (def_id, traits) in &tcx.resolutions(()).doc_link_traits_in_scope { +- record_array!(self.tables.doc_link_traits_in_scope[def_id.to_def_id()] <- traits); ++ if tcx.impl_method_has_trait_impl_trait_tys(def_id) ++ && let Ok(table) = self.tcx.collect_return_position_impl_trait_in_trait_tys(def_id) ++ { ++ record!(self.tables.collect_return_position_impl_trait_in_trait_tys[def_id] <- table); ++ } ++ if let DefKind::Impl { .. } | DefKind::Trait = def_kind { ++ let table = tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id); ++ record!(self.tables.associated_types_for_impl_traits_in_trait_or_impl[def_id] <- table); + } + } + +@@ -1859,77 +1911,256 @@ fn encode_precise_capturing_args(&mut self, def_id: DefId) { + record_array!(self.tables.rendered_precise_capturing_args[def_id] <- precise_capturing_args); + } + +- fn encode_mir(&mut self) { +- if self.is_proc_macro { +- return; ++ fn encode_mir_for(&mut self, def_id: LocalDefId, encode_const: bool, encode_opt: bool) { ++ let tcx = self.tcx; ++ debug_assert!(encode_const || encode_opt); ++ ++ debug!("EntryBuilder::encode_mir({:?})", def_id); ++ if encode_opt { ++ record!(self.tables.optimized_mir[def_id.to_def_id()] <- tcx.optimized_mir(def_id)); ++ self.tables ++ .cross_crate_inlinable ++ .set(def_id.to_def_id().index, self.tcx.cross_crate_inlinable(def_id)); ++ record!(self.tables.closure_saved_names_of_captured_variables[def_id.to_def_id()] ++ <- tcx.closure_saved_names_of_captured_variables(def_id)); ++ ++ if self.tcx.is_coroutine(def_id.to_def_id()) ++ && let Some(witnesses) = tcx.mir_coroutine_witnesses(def_id) ++ { ++ record!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses); ++ } + } ++ let mut is_trivial = false; ++ if encode_const { ++ if let Some((val, ty)) = tcx.trivial_const(def_id) { ++ is_trivial = true; ++ record!(self.tables.trivial_const[def_id.to_def_id()] <- (val, ty)); ++ } else { ++ is_trivial = false; ++ record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- tcx.mir_for_ctfe(def_id)); ++ } + +- let tcx = self.tcx; +- let reachable_set = tcx.reachable_set(()); ++ // FIXME(generic_const_exprs): this feels wrong to have in `encode_mir` ++ let abstract_const = tcx.thir_abstract_const(def_id); ++ if let Ok(Some(abstract_const)) = abstract_const { ++ record!(self.tables.thir_abstract_const[def_id.to_def_id()] <- abstract_const); ++ } + +- let keys_and_jobs = tcx.mir_keys(()).iter().filter_map(|&def_id| { +- let (encode_const, encode_opt) = should_encode_mir(tcx, reachable_set, def_id); +- if encode_const || encode_opt { Some((def_id, encode_const, encode_opt)) } else { None } +- }); +- for (def_id, encode_const, encode_opt) in keys_and_jobs { +- debug_assert!(encode_const || encode_opt); ++ if should_encode_const(tcx.def_kind(def_id)) { ++ let qualifs = tcx.mir_const_qualif(def_id); ++ record!(self.tables.mir_const_qualif[def_id.to_def_id()] <- qualifs); ++ let body = tcx.hir_maybe_body_owned_by(def_id); ++ if let Some(body) = body { ++ let const_data = rendered_const(self.tcx, &body, def_id); ++ record!(self.tables.rendered_const[def_id.to_def_id()] <- const_data); ++ } ++ } ++ } ++ if !is_trivial { ++ record!(self.tables.promoted_mir[def_id.to_def_id()] <- tcx.promoted_mir(def_id)); ++ } + +- debug!("EntryBuilder::encode_mir({:?})", def_id); +- if encode_opt { +- record!(self.tables.optimized_mir[def_id.to_def_id()] <- tcx.optimized_mir(def_id)); +- self.tables +- .cross_crate_inlinable +- .set(def_id.to_def_id().index, self.tcx.cross_crate_inlinable(def_id)); +- record!(self.tables.closure_saved_names_of_captured_variables[def_id.to_def_id()] +- <- tcx.closure_saved_names_of_captured_variables(def_id)); ++ if self.tcx.is_coroutine(def_id.to_def_id()) ++ && let Some(witnesses) = tcx.mir_coroutine_witnesses(def_id) ++ { ++ record!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses); ++ } ++ } + +- if self.tcx.is_coroutine(def_id.to_def_id()) +- && let Some(witnesses) = tcx.mir_coroutine_witnesses(def_id) +- { +- record!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses); ++ /// With `-Zearly-metadata`, function bodies aren't type-checked yet. If ++ /// `def_id` is nested in one (a closure, an inline const, a const ++ /// argument), returns that body's owner: `def_id` is encoded only if that ++ /// body is one of [`Self::interface_bodies`]. Coroutines are encoded ++ /// regardless: dependents read their witnesses to check `Send`. ++ fn early_enclosing_body(&self, def_id: LocalDefId) -> Option { ++ let tcx = self.tcx; ++ if !self.early { ++ return None; ++ } ++ match tcx.def_kind(def_id) { ++ DefKind::Closure | DefKind::SyntheticCoroutineBody => { ++ if tcx.is_coroutine(def_id.to_def_id()) { ++ return None; + } ++ return Some(tcx.typeck_root_def_id_local(def_id)); + } +- let mut is_trivial = false; +- if encode_const { +- if let Some((val, ty)) = tcx.trivial_const(def_id) { +- is_trivial = true; +- record!(self.tables.trivial_const[def_id.to_def_id()] <- (val, ty)); +- } else { +- is_trivial = false; +- record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- tcx.mir_for_ctfe(def_id)); ++ // Inline consts are type-checked with their parent body. ++ DefKind::AnonConst if tcx.is_typeck_child(def_id.to_def_id()) => { ++ return Some(tcx.typeck_root_def_id_local(def_id)); ++ } ++ DefKind::AnonConst => {} ++ _ => return None, ++ } ++ for (id, node) in tcx.hir_parent_iter(tcx.local_def_id_to_hir_id(def_id)) { ++ match node { ++ hir::Node::Expr(_) ++ | hir::Node::Block(_) ++ | hir::Node::Stmt(_) ++ | hir::Node::LetStmt(_) ++ | hir::Node::Pat(_) ++ | hir::Node::PatExpr(_) => { ++ return Some(tcx.typeck_root_def_id_local(tcx.hir_enclosing_body_owner(id))); + } +- +- // FIXME(generic_const_exprs): this feels wrong to have in `encode_mir` +- let abstract_const = tcx.thir_abstract_const(def_id); +- if let Ok(Some(abstract_const)) = abstract_const { +- record!(self.tables.thir_abstract_const[def_id.to_def_id()] <- abstract_const); ++ hir::Node::Item(_) ++ | hir::Node::TraitItem(_) ++ | hir::Node::ImplItem(_) ++ | hir::Node::ForeignItem(_) => return None, ++ _ => {} ++ } ++ } ++ None ++ } ++ ++ /// With `-Zearly-metadata`, the bodies whose type-checking the crate's ++ /// interface depends on, as a function of the crate's code alone: ++ /// ++ /// - bodies the encoder records MIR for: consts, const fns, coroutines; ++ /// - statics, which are evaluated before the early write; ++ /// - bodies that define an opaque type's hidden type. ++ /// ++ /// Definitions nested in any other body are left out of early metadata. ++ fn interface_bodies(&mut self) -> &FxHashSet { ++ let tcx = self.tcx; ++ if self.interface_bodies.is_none() { ++ let mut bodies = FxHashSet::default(); ++ for &def_id in tcx.mir_keys(()) { ++ if self.early_enclosing_body(def_id).is_some() { ++ continue; + } +- +- if should_encode_const(tcx.def_kind(def_id)) { +- let qualifs = tcx.mir_const_qualif(def_id); +- record!(self.tables.mir_const_qualif[def_id.to_def_id()] <- qualifs); +- let body = tcx.hir_maybe_body_owned_by(def_id); +- if let Some(body) = body { +- let const_data = rendered_const(self.tcx, &body, def_id); +- record!(self.tables.rendered_const[def_id.to_def_id()] <- const_data); ++ let (encode_const, encode_opt) = self.should_encode_mir(def_id); ++ if encode_const || encode_opt { ++ bodies.insert(tcx.typeck_root_def_id_local(def_id)); ++ } ++ } ++ let mut type_alias_opaques = FxHashSet::default(); ++ let items = tcx.hir_crate_items(()); ++ for def_id in items.definitions().chain(items.opaques()) { ++ match tcx.def_kind(def_id) { ++ DefKind::Static { .. } => { ++ bodies.insert(def_id); + } ++ DefKind::OpaqueTy => match tcx.local_opaque_ty_origin(def_id) { ++ hir::OpaqueTyOrigin::FnReturn { parent, .. } ++ | hir::OpaqueTyOrigin::AsyncFn { parent, .. } => { ++ bodies.insert(tcx.typeck_root_def_id_local(parent)); ++ } ++ hir::OpaqueTyOrigin::TyAlias { .. } => { ++ type_alias_opaques.insert(def_id); ++ } ++ }, ++ _ => {} + } + } +- if !is_trivial { +- record!(self.tables.promoted_mir[def_id.to_def_id()] <- tcx.promoted_mir(def_id)); ++ // A `type Alias = impl Trait` is defined by whichever bodies may ++ // define it. ++ if !type_alias_opaques.is_empty() { ++ for owner in tcx.hir_body_owners() { ++ if tcx ++ .opaque_types_defined_by(owner) ++ .iter() ++ .any(|opaque| type_alias_opaques.contains(&opaque)) ++ { ++ bodies.insert(tcx.typeck_root_def_id_local(owner)); ++ } ++ } + } ++ self.interface_bodies = Some(bodies); ++ } ++ self.interface_bodies.as_ref().unwrap() ++ } + +- if self.tcx.is_coroutine(def_id.to_def_id()) +- && let Some(witnesses) = tcx.mir_coroutine_witnesses(def_id) +- { +- record!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses); ++ /// Encodes the deferred MIR and definitions nested in interface bodies. ++ /// With `-Zearly-metadata-verify`, reports any left out whose body was ++ /// type-checked anyway: a body `interface_bodies` should have included. ++ fn encode_deferred(&mut self) { ++ let verify = self.tcx.sess.opts.unstable_opts.early_metadata_verify; ++ for (def_id, body, c, o) in std::mem::take(&mut self.deferred_mir) { ++ if self.interface_bodies().contains(&body) { ++ self.encode_mir_for(def_id, c, o); ++ } else if verify { ++ self.report_missed_body(def_id, body); ++ } ++ } ++ for (def_id, body) in std::mem::take(&mut self.deferred_defs) { ++ if self.interface_bodies().contains(&body) { ++ self.encode_def_id(def_id); ++ } else if verify { ++ self.report_missed_body(def_id, body); + } + } ++ } ++ ++ fn report_missed_body(&self, def_id: LocalDefId, body: LocalDefId) { ++ if self.tcx.typeck_is_done(body) { ++ eprintln!( ++ "early-metadata-verify: left out `{}`, but `{}` was type-checked \ ++ during the early write", ++ self.tcx.def_path_debug_str(def_id.to_def_id()), ++ self.tcx.def_path_debug_str(body.to_def_id()), ++ ); ++ } ++ } ++ ++ /// `should_encode_mir`, for the kind of metadata being written. ++ /// ++ /// Early metadata records optimized MIR only for coroutines, whose ++ /// layout dependents compute during analysis (the MIR inliner leaves ++ /// coroutine bodies alone). Optimizing any other body would type-check ++ /// it, and would run the MIR inliner, which asks dependencies loaded ++ /// from early metadata whether they have MIR. They say no, and that ++ /// answer would stay cached after their full metadata is loaded. ++ /// ++ /// Early metadata doesn't consult the reachable set either: computing it ++ /// walks the bodies of inline and generic functions. Neither does ++ /// metadata written without code generation, which never reads it. With ++ /// `-Zearly-metadata`, dependencies may still be loaded from early ++ /// metadata then, and optimizing those bodies would ask them for MIR. ++ fn should_encode_mir(&self, def_id: LocalDefId) -> (bool, bool) { ++ let tcx = self.tcx; ++ if !self.early ++ && (tcx.sess.opts.output_types.should_codegen() ++ || !tcx.sess.opts.unstable_opts.early_metadata) ++ { ++ return should_encode_mir(tcx, tcx.reachable_set(()), def_id); ++ } ++ if !self.early { ++ return should_encode_mir(tcx, &LocalDefIdSet::default(), def_id); ++ } ++ let (encode_const, encode_opt) = should_encode_mir(tcx, &LocalDefIdSet::default(), def_id); ++ let coroutine = match tcx.def_kind(def_id) { ++ DefKind::Closure => tcx.is_coroutine(def_id.to_def_id()), ++ DefKind::SyntheticCoroutineBody => true, ++ _ => false, ++ }; ++ (encode_const, encode_opt && coroutine) ++ } ++ ++ fn encode_mir(&mut self) { ++ if self.is_proc_macro { ++ return; ++ } ++ ++ let tcx = self.tcx; ++ let keys_and_jobs = tcx.mir_keys(()).iter().filter_map(|&def_id| { ++ let (encode_const, encode_opt) = self.should_encode_mir(def_id); ++ if encode_const || encode_opt { Some((def_id, encode_const, encode_opt)) } else { None } ++ }); ++ for (def_id, encode_const, encode_opt) in keys_and_jobs.collect::>() { ++ if let Some(body) = self.early_enclosing_body(def_id) { ++ self.deferred_mir.push((def_id, body, encode_const, encode_opt)); ++ continue; ++ } ++ self.encode_mir_for(def_id, encode_const, encode_opt); ++ } + + // Encode all the deduced parameter attributes for everything that has MIR, even for items + // that can't be inlined. But don't if we aren't optimizing in non-incremental mode, to + // save the query traffic. +- if tcx.sess.opts.output_types.should_codegen() ++ // ++ // Not in early metadata: deducing them optimizes every body, and only code generation ++ // reads them, from full metadata. ++ if !self.early ++ && tcx.sess.opts.output_types.should_codegen() + && tcx.sess.opts.optimize != OptLevel::No + && tcx.sess.opts.incremental.is_none() + { +@@ -2401,6 +2632,27 @@ fn prefetch_mir(tcx: TyCtxt<'_>) { + }) + } + ++/// `prefetch_mir` for early metadata: the MIR of consts and const fns. ++/// Anonymous consts are left alone: those in bodies (const arguments, ++/// array lengths) are typed by type-checking the enclosing body. ++fn prefetch_early_mir(tcx: TyCtxt<'_>) { ++ let unreachable = LocalDefIdSet::default(); ++ par_for_each_in(tcx.mir_keys(()), |&&def_id| { ++ if !matches!( ++ tcx.def_kind(def_id), ++ DefKind::Const | DefKind::AssocConst | DefKind::Fn | DefKind::AssocFn ++ ) || tcx.is_trivial_const(def_id) ++ { ++ return; ++ } ++ let (encode_const, _) = should_encode_mir(tcx, &unreachable, def_id); ++ if encode_const { ++ tcx.ensure_done().mir_for_ctfe(def_id); ++ tcx.ensure_done().promoted_mir(def_id); ++ } ++ }) ++} ++ + // NOTE(eddyb) The following comment was preserved for posterity, even + // though it's no longer relevant as EBML (which uses nested & tagged + // "documents") was replaced with a scheme that can't go out of bounds. +@@ -2543,13 +2795,17 @@ pub fn encode_metadata(tcx: TyCtxt<'_>, path: &Path, ref_path: Option<&Path>) { + let owned = slice_owned(mmap, Deref::deref); + let blob = MetadataBlob::new(owned); + let hash = blob.expect("file already created").get_crate_hash(); +- tcx.untracked().local_crate_hash.set(hash).expect("local_crate_hash set twice"); ++ match tcx.untracked().local_crate_hash.get() { ++ // Early metadata was encoded first. ++ Some(&early) => assert_eq!(early, hash, "early and full metadata disagree on the SVH"), ++ None => tcx.untracked().local_crate_hash.set(hash).unwrap(), ++ } + + // Generate the metadata stub manually, as that is a small file compared to full metadata. + if let Some(ref_path) = ref_path { + let _prof_timer = tcx.prof.verbose_generic_activity("generate_crate_metadata_stub"); + +- with_encode_metadata_header(tcx, ref_path, |ecx| { ++ with_encode_metadata_header(tcx, ref_path, false, |ecx| { + let header: LazyValue = ecx.lazy(CrateHeader { + name: tcx.crate_name(LOCAL_CRATE), + triple: tcx.sess.opts.target_triple.clone(), +@@ -2582,7 +2838,7 @@ pub fn encode_metadata(tcx: TyCtxt<'_>, path: &Path, ref_path: Option<&Path>) { + dep_node, + tcx, + || { +- with_encode_metadata_header(tcx, path, |ecx| { ++ with_encode_metadata_header(tcx, path, false, |ecx| { + // Encode all the entries and extra information in the crate, + // culminating in the `CrateRoot` which points to all of it. + let (root, unhashed) = ecx.encode_crate_root(); +@@ -2606,7 +2862,7 @@ pub fn encode_metadata(tcx: TyCtxt<'_>, path: &Path, ref_path: Option<&Path>) { + if let Some(ref_path) = ref_path { + let _prof_timer = tcx.prof.verbose_generic_activity("generate_crate_metadata_stub"); + +- with_encode_metadata_header(tcx, ref_path, |ecx| { ++ with_encode_metadata_header(tcx, ref_path, false, |ecx| { + let header: LazyValue = ecx.lazy(CrateHeader { + name: tcx.crate_name(LOCAL_CRATE), + triple: tcx.sess.opts.target_triple.clone(), +@@ -2618,9 +2874,28 @@ pub fn encode_metadata(tcx: TyCtxt<'_>, path: &Path, ref_path: Option<&Path>) { + } + } + ++/// Encodes early metadata (`-Zearly-metadata`) to `path`: the crate's item ++/// interfaces, written after `analysis_interfaces` and before function bodies ++/// are checked, so dependents can start compiling. It isn't tracked for ++/// incremental reuse; it's cheap and always re-encoded. ++pub fn encode_early_metadata(tcx: TyCtxt<'_>, path: &Path) { ++ tcx.dep_graph.assert_ignored(); ++ let _prof_timer = tcx.prof.verbose_generic_activity("generate_crate_metadata_early"); ++ if tcx.sess.opts.jobs.frontend.is_some() { ++ // As for full metadata: not necessary for correctness, only for performance. ++ prefetch_early_mir(tcx); ++ } ++ with_encode_metadata_header(tcx, path, true, |ecx| { ++ let (root, unhashed) = ecx.encode_crate_root(); ++ ecx.opaque.flush(); ++ (root.position.get(), unhashed.position.get()) ++ }) ++} ++ + fn with_encode_metadata_header( + tcx: TyCtxt<'_>, + path: &Path, ++ early: bool, + f: impl FnOnce(&mut EncodeContext<'_, '_>) -> (usize, usize), + ) { + // By default the crate hash (SVH) is computed from the bytes of the encoded metadata, +@@ -2691,6 +2966,10 @@ fn with_encode_metadata_header( + is_proc_macro: tcx.crate_types().contains(&CrateType::ProcMacro), + hygiene_ctxt: Default::default(), + symbol_index_table: Default::default(), ++ early, ++ interface_bodies: None, ++ deferred_mir: Default::default(), ++ deferred_defs: Default::default(), + }; + + // Encode the rustc version string in a predictable location. +diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs +index e3f3257ac..afa845eac 100644 +--- a/compiler/rustc_metadata/src/rmeta/mod.rs ++++ b/compiler/rustc_metadata/src/rmeta/mod.rs +@@ -6,7 +6,7 @@ + pub(crate) use decoder::{CrateMetadata, CrateNumMap, MetadataBlob, TargetModifiers}; + use def_path_hash_map::DefPathHashMapRef; + use encoder::EncodeContext; +-pub use encoder::{EncodedMetadata, encode_metadata, rendered_const}; ++pub use encoder::{EncodedMetadata, encode_early_metadata, encode_metadata, rendered_const}; + pub(crate) use parameterized::ParameterizedOverTcx; + use rustc_abi::{FieldIdx, ReprOptions, VariantIdx}; + use rustc_ast as ast; +diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs +index ddaf12f98..9b0e3ac58 100644 +--- a/compiler/rustc_middle/src/queries.rs ++++ b/compiler/rustc_middle/src/queries.rs +@@ -403,6 +403,17 @@ fn describe_as_module(def_id: impl Into, tcx: TyCtxt<'_>) -> String + } + } + ++ /// The analysis passes that check the crate's item interfaces, before any ++ /// function body is type-checked. `analysis` runs these first; with ++ /// `-Zearly-metadata`, the driver writes early metadata after them. ++ query analysis_interfaces(key: ()) { ++ eval_always ++ desc { ++ "checking item interfaces of crate `{}`", ++ tcx.crate_name(LOCAL_CRATE), ++ } ++ } ++ + /// The root query triggering all analysis passes like typeck or borrowck. + query analysis(key: ()) { + eval_always +diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs +index 5cd7322ce..b76b88ca8 100644 +--- a/compiler/rustc_middle/src/ty/context.rs ++++ b/compiler/rustc_middle/src/ty/context.rs +@@ -1372,7 +1372,19 @@ pub fn create_crate_num( + pub fn iter_local_def_id(self) -> impl Iterator { + // Depend on the `analysis` query to ensure compilation if finished. + self.ensure_ok().analysis(()); ++ self.iter_local_def_id_unchecked() ++ } ++ ++ /// Like [`Self::iter_local_def_id`], but only requires the crate's item ++ /// interfaces to be checked (`analysis_interfaces`). For `-Zearly-metadata`, ++ /// which encodes metadata before function bodies are checked. The caller ++ /// must first create any definitions that checking bodies would add. ++ pub fn iter_local_def_id_after_interfaces(self) -> impl Iterator { ++ self.ensure_ok().analysis_interfaces(()); ++ self.iter_local_def_id_unchecked() ++ } + ++ fn iter_local_def_id_unchecked(self) -> impl Iterator { + let definitions = &self.untracked.definitions; + gen { + let mut i = 0; +@@ -1390,6 +1402,20 @@ pub fn iter_local_def_id(self) -> impl Iterator { + } + } + ++ /// Whether `typeck(def_id)` has already been computed in this session, ++ /// without computing it. Only for `-Zearly-metadata-verify`'s report. ++ pub fn typeck_is_done(self, def_id: LocalDefId) -> bool { ++ let root = self.typeck_root_def_id_local(def_id); ++ self.query_system.query_vtables.typeck_root.cache.lookup(&root).is_some() ++ } ++ ++ /// Like [`Self::definitions`], but only requires the crate's item ++ /// interfaces to be checked; see [`Self::iter_local_def_id_after_interfaces`]. ++ pub fn definitions_after_interfaces(self) -> &'tcx rustc_hir::definitions::Definitions { ++ self.ensure_ok().analysis_interfaces(()); ++ self.untracked.definitions.freeze() ++ } ++ + pub fn definitions(self) -> &'tcx rustc_hir::definitions::Definitions { + // Depend on the `analysis` query to ensure compilation if finished. + self.ensure_ok().analysis(()); +diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs +index 0e0671301..93cfeb52a 100644 +--- a/compiler/rustc_session/src/options.rs ++++ b/compiler/rustc_session/src/options.rs +@@ -2492,6 +2492,13 @@ pub(crate) fn parse_rust_version(slot: &mut Option, v: Option<&str + eagerly_emit_delayed_bugs: bool = (false, parse_bool, [UNTRACKED], + "emit delayed bugs eagerly as errors instead of stashing them and emitting \ + them only if an error has not been emitted"), ++ early_metadata: bool = (false, parse_bool, [TRACKED], ++ "write crate metadata as soon as item interfaces are checked, before function \ ++ bodies are, so dependent crates can start sooner (default: no)"), ++ early_metadata_verify: bool = (false, parse_bool, [UNTRACKED], ++ "with `-Zearly-metadata`, report bodies type-checked during the early write whose \ ++ nested definitions were left out of it, and queries only full metadata can answer \ ++ asked of crates loaded from early metadata (default: no)"), + ehcont_guard: bool = (false, parse_bool, [TRACKED], + "generate Windows EHCont Guard tables"), + embed_metadata: bool = (true, parse_bool, [TRACKED], diff --git a/projects/bevy.Cargo.lock b/projects/bevy.Cargo.lock new file mode 100644 index 0000000..7976901 --- /dev/null +++ b/projects/bevy.Cargo.lock @@ -0,0 +1,11189 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "ab_glyph" +version = "0.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2" +dependencies = [ + "ab_glyph_rasterizer", + "owned_ttf_parser", +] + +[[package]] +name = "ab_glyph_rasterizer" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618" + +[[package]] +name = "accesskit" +version = "0.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "438a7081a65b95c668db56591a4fef9bc5dad275f448bd6223fc6949d823db38" +dependencies = [ + "enumn", + "serde", + "uuid", +] + +[[package]] +name = "accesskit_atspi_common" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9d47ad644916f6cb7e432a5ca0dbd7cc78281a9772881057bb72d4aadb93257" +dependencies = [ + "accesskit", + "accesskit_consumer", + "atspi-common", + "phf 0.14.0", + "serde", + "zvariant", +] + +[[package]] +name = "accesskit_consumer" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc882fa0c9c24c53649e256311b51046cf36eca9a8f7e54ff4ef682160b0cb27" +dependencies = [ + "accesskit", + "hashbrown 0.17.1", +] + +[[package]] +name = "accesskit_ios" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5e9b29c6ba5f4d2e0662e9c562484f061ffc58f658479c538ecca8299ada1e9" +dependencies = [ + "accesskit", + "accesskit_consumer", + "hashbrown 0.17.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", + "objc2-ui-kit", +] + +[[package]] +name = "accesskit_macos" +version = "0.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3f278988416e5fb600f24d0cfffe31a249ebbff980fb9c5a3b5fbed2c579f73" +dependencies = [ + "accesskit", + "accesskit_consumer", + "hashbrown 0.17.1", + "objc2 0.5.2", + "objc2-app-kit 0.2.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "accesskit_unix" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "665c9079b7325a8168a6793437a172dda44b19a05af8ed52d7e32abaada996fe" +dependencies = [ + "accesskit", + "accesskit_atspi_common", + "async-channel", + "async-executor", + "async-task", + "atspi", + "futures-lite", + "futures-util", + "serde", + "zbus", +] + +[[package]] +name = "accesskit_windows" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a59e8d7160cbac991c1345c99153783ab96423644ccb1f20617cf80c97596aa1" +dependencies = [ + "accesskit", + "accesskit_consumer", + "hashbrown 0.17.1", + "static_assertions", + "windows", + "windows-core", +] + +[[package]] +name = "accesskit_winit" +version = "0.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1eb960a51582305f94b3884a7ff54b3462abe38f0de95a9e7e04dd7ab7b757da" +dependencies = [ + "accesskit", + "accesskit_ios", + "accesskit_macos", + "accesskit_unix", + "accesskit_windows", + "raw-window-handle", + "winit", +] + +[[package]] +name = "addr2line" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "getrandom 0.3.4", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloca" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4" +dependencies = [ + "cc", +] + +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + +[[package]] +name = "alsa" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "812947049edcd670a82cd5c73c3661d2e58468577ba8489de58e1a73c04cbd5d" +dependencies = [ + "alsa-sys", + "bitflags 2.13.2", + "cfg-if", + "libc", +] + +[[package]] +name = "alsa-sys" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad7569085a265dd3f607ebecce7458eaab2132a84393534c95b18dcbc3f31e04" +dependencies = [ + "libc", + "pkg-config", +] + +[[package]] +name = "android-activity" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f2a1bb052857d5dd49572219344a7332b31b76405648eabac5bc68978251bcd" +dependencies = [ + "android-properties", + "bitflags 2.13.2", + "cc", + "jni 0.22.4", + "libc", + "log", + "ndk", + "ndk-context", + "ndk-sys", + "num_enum", + "simd_cesu8", + "thiserror 2.0.21", +] + +[[package]] +name = "android-properties" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04" + +[[package]] +name = "android_log-sys" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84521a3cf562bc62942e294181d9eef17eb38ceb8c68677bc49f144e4c3d4f8d" + +[[package]] +name = "android_system_properties" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc" +dependencies = [ + "libc", +] + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "annotate-snippets" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "710e8eae58854cdc1790fcb56cca04d712a17be849eeb81da2a724bf4bae2bc4" +dependencies = [ + "anstyle", + "unicode-width 0.2.2", +] + +[[package]] +name = "annotate-snippets" +version = "0.12.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f211a51805bc641f3ad5b7664c77d2547af685cc33b4cd8d31964027a46f13f1" +dependencies = [ + "anstyle", + "memchr", + "unicode-width 0.2.2", +] + +[[package]] +name = "anstream" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "anstyle-parse" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys 0.61.2", +] + +[[package]] +name = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "approx" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6" +dependencies = [ + "num-traits", +] + +[[package]] +name = "arboard" +version = "3.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf" +dependencies = [ + "clipboard-win", + "image", + "log", + "objc2 0.6.4", + "objc2-app-kit 0.3.2", + "objc2-core-foundation", + "objc2-core-graphics", + "objc2-foundation 0.3.2", + "parking_lot", + "percent-encoding", + "windows-sys 0.60.2", + "wl-clipboard-rs", + "x11rb", +] + +[[package]] +name = "argh" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "211818e820cda9ca6f167a64a5c808837366a6dfd807157c64c1304c486cd033" +dependencies = [ + "argh_derive", + "argh_shared", +] + +[[package]] +name = "argh_derive" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c442a9d18cef5dde467405d27d461d080d68972d6d0dfd0408265b6749ec427d" +dependencies = [ + "argh_shared", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "argh_shared" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5ade012bac4db278517a0132c8c10c6427025868dca16c801087c28d5a411f1" +dependencies = [ + "serde", +] + +[[package]] +name = "arrayref" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" + +[[package]] +name = "arrayvec" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56" + +[[package]] +name = "as-raw-xcb-connection" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b" + +[[package]] +name = "ascii-canvas" +version = "4.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef1e3e699d84ab1b0911a1010c5c106aa34ae89aeac103be5ce0c3859db1e891" +dependencies = [ + "term", +] + +[[package]] +name = "ash" +version = "0.38.0+1.3.281" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f" +dependencies = [ + "libloading", +] + +[[package]] +name = "assert_type_match" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f548ad2c4031f2902e3edc1f29c29e835829437de49562d8eb5dc5584d3a1043" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "async-broadcast" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532" +dependencies = [ + "event-listener", + "event-listener-strategy", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-channel" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2" +dependencies = [ + "concurrent-queue", + "event-listener-strategy", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-executor" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a" +dependencies = [ + "async-task", + "concurrent-queue", + "fastrand", + "futures-lite", + "pin-project-lite", + "slab", +] + +[[package]] +name = "async-fs" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5" +dependencies = [ + "async-lock", + "blocking", + "futures-lite", +] + +[[package]] +name = "async-io" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc" +dependencies = [ + "autocfg", + "cfg-if", + "concurrent-queue", + "futures-io", + "futures-lite", + "parking", + "polling", + "rustix 1.1.5", + "slab", + "windows-sys 0.61.2", +] + +[[package]] +name = "async-lock" +version = "3.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311" +dependencies = [ + "event-listener", + "event-listener-strategy", + "pin-project-lite", +] + +[[package]] +name = "async-process" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75" +dependencies = [ + "async-channel", + "async-io", + "async-lock", + "async-signal", + "async-task", + "blocking", + "cfg-if", + "event-listener", + "futures-lite", + "rustix 1.1.5", +] + +[[package]] +name = "async-recursion" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "async-signal" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485" +dependencies = [ + "async-io", + "async-lock", + "atomic-waker", + "cfg-if", + "futures-core", + "futures-io", + "rustix 1.1.5", + "signal-hook-registry", + "slab", + "windows-sys 0.61.2", +] + +[[package]] +name = "async-task" +version = "4.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "async-trait" +version = "0.1.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "atomic" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89cbf775b137e9b968e67227ef7f775587cde3fd31b0d8599dbd0f598a48340" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "atomic-polyfill" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4" +dependencies = [ + "critical-section", +] + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "atomicow" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "301801c08259e328a1c7da556608c0c22687708831b22024dbd3a57ea741e6de" +dependencies = [ + "portable-atomic", + "portable-atomic-util", +] + +[[package]] +name = "atspi" +version = "0.29.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c77886257be21c9cd89a4ae7e64860c6f0eefca799bb79127913052bd0eefb3d" +dependencies = [ + "atspi-common", + "atspi-proxies", +] + +[[package]] +name = "atspi-common" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20c5617155740c98003016429ad13fe43ce7a77b007479350a9f8bf95a29f63d" +dependencies = [ + "enumflags2", + "serde", + "static_assertions", + "zbus", + "zbus-lockstep", + "zbus-lockstep-macros", + "zbus_names", + "zvariant", +] + +[[package]] +name = "atspi-proxies" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2230e48787ed3eb4088996eab66a32ca20c0b67bbd4fd6cdfe79f04f1f04c9fc" +dependencies = [ + "atspi-common", + "serde", + "zbus", +] + +[[package]] +name = "auto_register_static" +version = "0.0.0" +dependencies = [ + "bevy", +] + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "backtrace" +version = "0.3.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6" +dependencies = [ + "addr2line", + "cfg-if", + "libc", + "miniz_oxide 0.8.9", + "object", + "rustc-demangle", + "windows-link", +] + +[[package]] +name = "backtrace-ext" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "537beee3be4a18fb023b570f80e3ae28003db9167a751266b259926e25539d50" +dependencies = [ + "backtrace", +] + +[[package]] +name = "base64" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "base64" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5" + +[[package]] +name = "basis-universal" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "555fb05709f4e12fa2f6b93a480facf167eb0ecb2558ba41f610f588e77cbd14" +dependencies = [ + "basis-universal-sys", + "bitflags 1.3.2", + "lazy_static", +] + +[[package]] +name = "basis-universal-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd9bde5e9547958fb0e77d79fc7879edcf91d5e0c8e372ef8959916cf35e8506" +dependencies = [ + "cc", +] + +[[package]] +name = "benches" +version = "0.0.0" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_curve", + "bevy_ecs", + "bevy_extract", + "bevy_math", + "bevy_mesh", + "bevy_picking", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_scene", + "bevy_shape", + "bevy_tasks", + "bevy_transform", + "bevy_ui", + "bevy_ui_widgets", + "bytemuck", + "chacha20", + "criterion", + "glam", + "nonmax", + "rand 0.10.3", + "seq-macro", +] + +[[package]] +name = "bevy" +version = "0.20.0-dev" +dependencies = [ + "accesskit", + "anyhow", + "argh", + "bevy-settings", + "bevy_animation", + "bevy_asset", + "bevy_dylib", + "bevy_ecs", + "bevy_extract", + "bevy_gizmos", + "bevy_image", + "bevy_internal", + "bevy_reflect", + "bevy_render", + "bevy_scene", + "bevy_state", + "bytemuck", + "chacha20", + "crossbeam-channel", + "event-listener", + "flate2", + "futures-lite", + "futures-timer", + "getrandom 0.4.3", + "gltf", + "indexmap", + "nonmax", + "rand 0.10.3", + "ron", + "serde", + "serde_json", + "thiserror 2.0.21", + "tracing", + "ureq", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "bevy-settings" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_ecs_macros", + "bevy_log", + "bevy_platform", + "bevy_reflect", + "bevy_tasks", + "bevy_time", + "serde", + "thiserror 2.0.21", + "toml", + "web-sys", +] + +[[package]] +name = "bevy_a11y" +version = "0.20.0-dev" +dependencies = [ + "accesskit", + "bevy_app", + "bevy_derive", + "bevy_ecs", + "bevy_reflect", + "serde", +] + +[[package]] +name = "bevy_android" +version = "0.20.0-dev" +dependencies = [ + "android-activity", +] + +[[package]] +name = "bevy_animation" +version = "0.20.0-dev" +dependencies = [ + "bevy_animation_macros", + "bevy_app", + "bevy_asset", + "bevy_color", + "bevy_curve", + "bevy_derive", + "bevy_ecs", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_time", + "bevy_transform", + "bevy_utils", + "bitvec", + "blake3", + "derive_more", + "downcast-rs 2.0.2", + "either", + "itertools 0.14.0", + "petgraph", + "ron", + "serde", + "smallvec", + "thiserror 2.0.21", + "thread_local", + "tracing", + "uuid", +] + +[[package]] +name = "bevy_animation_macros" +version = "0.20.0-dev" +dependencies = [ + "bevy_macro_utils", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_anti_alias" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_core_pipeline", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_math", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_utils", + "dlss_wgpu", + "tracing", + "uuid", +] + +[[package]] +name = "bevy_app" +version = "0.20.0-dev" +dependencies = [ + "bevy_derive", + "bevy_ecs", + "bevy_platform", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "console_error_panic_hook", + "crossbeam-channel", + "ctrlc", + "dioxus-devtools", + "downcast-rs 2.0.2", + "log", + "thiserror 2.0.21", + "tracing", + "variadics_please", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "bevy_asset" +version = "0.20.0-dev" +dependencies = [ + "async-broadcast", + "async-channel", + "async-fs", + "async-io", + "async-lock", + "atomicow", + "bevy_android", + "bevy_app", + "bevy_asset_macros", + "bevy_diagnostic", + "bevy_ecs", + "bevy_platform", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "bitflags 2.13.2", + "blake3", + "blocking", + "crossbeam-channel", + "derive_more", + "disqualified", + "downcast-rs 2.0.2", + "either", + "futures-io", + "futures-lite", + "futures-util", + "js-sys", + "notify-debouncer-full", + "ron", + "serde", + "stackfuture", + "thiserror 2.0.21", + "tracing", + "ureq", + "uuid", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "bevy_asset_macros" +version = "0.20.0-dev" +dependencies = [ + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_audio" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_ecs", + "bevy_math", + "bevy_reflect", + "bevy_transform", + "rodio", + "tracing", +] + +[[package]] +name = "bevy_camera" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_color", + "bevy_derive", + "bevy_ecs", + "bevy_image", + "bevy_math", + "bevy_mesh", + "bevy_reflect", + "bevy_scene", + "bevy_shape", + "bevy_transform", + "bevy_utils", + "bevy_window", + "derive_more", + "downcast-rs 2.0.2", + "serde", + "smallvec", + "thiserror 2.0.21", + "wgpu-types", +] + +[[package]] +name = "bevy_camera_controller" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_curve", + "bevy_derive", + "bevy_ecs", + "bevy_gizmos", + "bevy_image", + "bevy_input", + "bevy_log", + "bevy_math", + "bevy_picking", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_time", + "bevy_transform", + "bevy_window", +] + +[[package]] +name = "bevy_city" +version = "0.1.0" +dependencies = [ + "argh", + "bevy", + "noise", + "rand 0.10.3", +] + +[[package]] +name = "bevy_clipboard" +version = "0.20.0-dev" +dependencies = [ + "arboard", + "bevy_app", + "bevy_asset", + "bevy_ecs", + "bevy_image", + "bevy_log", + "bevy_platform", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "wgpu-types", +] + +[[package]] +name = "bevy_color" +version = "0.20.0-dev" +dependencies = [ + "bevy_curve", + "bevy_math", + "bevy_reflect", + "bytemuck", + "derive_more", + "encase", + "serde", + "thiserror 2.0.21", + "wgpu-types", +] + +[[package]] +name = "bevy_core_pipeline" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_light", + "bevy_log", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_transform", + "bevy_utils", + "bevy_window", + "bitflags 2.13.2", + "indexmap", + "nonmax", +] + +[[package]] +name = "bevy_curve" +version = "0.20.0-dev" +dependencies = [ + "approx", + "bevy_math", + "bevy_reflect", + "itertools 0.14.0", + "serde", + "thiserror 2.0.21", + "variadics_please", +] + +[[package]] +name = "bevy_derive" +version = "0.20.0-dev" +dependencies = [ + "bevy_macro_utils", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_derive_compile_fail" +version = "0.0.0" +dependencies = [ + "bevy_derive", + "compile_fail_utils", +] + +[[package]] +name = "bevy_dev_tools" +version = "0.20.0-dev" +dependencies = [ + "bevy_animation", + "bevy_app", + "bevy_asset", + "bevy_audio", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_diagnostic", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_input", + "bevy_light", + "bevy_log", + "bevy_math", + "bevy_mesh", + "bevy_pbr", + "bevy_picking", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_sprite", + "bevy_state", + "bevy_text", + "bevy_time", + "bevy_transform", + "bevy_ui", + "bevy_ui_render", + "bevy_ui_widgets", + "bevy_utils", + "bevy_window", + "bevy_world_serialization", + "ron", + "serde", + "serde_json", + "strsim", + "thiserror 2.0.21", + "tracing", + "x264", +] + +[[package]] +name = "bevy_diagnostic" +version = "0.20.0-dev" +dependencies = [ + "atomic-waker", + "bevy_app", + "bevy_ecs", + "bevy_platform", + "bevy_tasks", + "bevy_time", + "const-fnv1a-hash", + "log", + "serde", + "serde_test", + "sysinfo", +] + +[[package]] +name = "bevy_dylib" +version = "0.20.0-dev" +dependencies = [ + "bevy_internal", +] + +[[package]] +name = "bevy_ecs" +version = "0.20.0-dev" +dependencies = [ + "arrayvec", + "bevy_ecs_macros", + "bevy_platform", + "bevy_ptr", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "bitflags 2.13.2", + "bumpalo", + "concurrent-queue", + "derive_more", + "fixedbitset 0.5.7", + "indexmap", + "log", + "nonmax", + "rand 0.10.3", + "serde", + "serde_test", + "slotmap", + "smallvec", + "static_assertions", + "subsecond", + "thiserror 2.0.21", + "tracing", + "variadics_please", +] + +[[package]] +name = "bevy_ecs_compile_fail" +version = "0.0.0" +dependencies = [ + "bevy_ecs", + "compile_fail_utils", +] + +[[package]] +name = "bevy_ecs_macro_logic" +version = "0.20.0-dev" +dependencies = [ + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_ecs_macros" +version = "0.20.0-dev" +dependencies = [ + "bevy_ecs_macro_logic", + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_encase_derive" +version = "0.20.0-dev" +dependencies = [ + "bevy_macro_utils", + "encase_derive_impl", +] + +[[package]] +name = "bevy_extract" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_camera", + "bevy_derive", + "bevy_ecs", + "bevy_extract_macros", + "bevy_log", + "bevy_platform", + "bevy_reflect", + "bevy_time", + "bevy_utils", +] + +[[package]] +name = "bevy_extract_macros" +version = "0.20.0-dev" +dependencies = [ + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_feathers" +version = "0.20.0-dev" +dependencies = [ + "accesskit", + "bevy_a11y", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_derive", + "bevy_ecs", + "bevy_input", + "bevy_input_focus", + "bevy_log", + "bevy_math", + "bevy_picking", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_scene", + "bevy_shader", + "bevy_text", + "bevy_ui", + "bevy_ui_render", + "bevy_ui_widgets", + "bevy_window", + "smol_str", +] + +[[package]] +name = "bevy_gilrs" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_input", + "bevy_platform", + "bevy_time", + "gilrs", + "thiserror 2.0.21", + "tracing", +] + +[[package]] +name = "bevy_gizmos" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_curve", + "bevy_ecs", + "bevy_gizmos_macros", + "bevy_input", + "bevy_log", + "bevy_math", + "bevy_mesh", + "bevy_reflect", + "bevy_shape", + "bevy_time", + "bevy_transform", + "bevy_utils", + "bevy_window", +] + +[[package]] +name = "bevy_gizmos_macros" +version = "0.20.0-dev" +dependencies = [ + "bevy_macro_utils", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_gizmos_render" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_ecs", + "bevy_extract", + "bevy_gizmos", + "bevy_image", + "bevy_log", + "bevy_material", + "bevy_math", + "bevy_mesh", + "bevy_pbr", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_shape", + "bevy_sprite_render", + "bevy_transform", + "bevy_utils", + "bytemuck", + "tracing", +] + +[[package]] +name = "bevy_gltf" +version = "0.20.0-dev" +dependencies = [ + "async-lock", + "base64 0.23.1", + "bevy_animation", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_curve", + "bevy_ecs", + "bevy_image", + "bevy_light", + "bevy_log", + "bevy_material", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_tasks", + "bevy_transform", + "bevy_world_serialization", + "fixedbitset 0.5.7", + "gltf", + "itertools 0.14.0", + "percent-encoding", + "serde", + "serde_json", + "smallvec", + "thiserror 2.0.21", + "tracing", + "wgpu-types", +] + +[[package]] +name = "bevy_image" +version = "0.20.0-dev" +dependencies = [ + "basis-universal", + "bevy_app", + "bevy_asset", + "bevy_color", + "bevy_ecs", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "bevy_utils", + "bitflags 2.13.2", + "bytemuck", + "ctt", + "ddsfile", + "flate2", + "futures-lite", + "guillotiere", + "half", + "image", + "ktx2", + "rectangle-pack", + "ruzstd", + "serde", + "serde_json", + "thiserror 2.0.21", + "tracing", + "wgpu-types", + "zstd", +] + +[[package]] +name = "bevy_input" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "derive_more", + "log", + "serde", + "smol_str", + "thiserror 2.0.21", +] + +[[package]] +name = "bevy_input_focus" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_camera", + "bevy_ecs", + "bevy_input", + "bevy_math", + "bevy_picking", + "bevy_reflect", + "bevy_window", + "log", + "thiserror 2.0.21", +] + +[[package]] +name = "bevy_inspector" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_dev_tools", + "bevy_ecs", + "bevy_feathers", + "bevy_image", + "bevy_log", + "bevy_platform", + "bevy_reflect", + "bevy_scene", + "bevy_text", + "bevy_time", + "bevy_ui", + "bevy_ui_widgets", +] + +[[package]] +name = "bevy_internal" +version = "0.20.0-dev" +dependencies = [ + "bevy-settings", + "bevy_a11y", + "bevy_android", + "bevy_animation", + "bevy_anti_alias", + "bevy_app", + "bevy_asset", + "bevy_audio", + "bevy_camera", + "bevy_camera_controller", + "bevy_clipboard", + "bevy_color", + "bevy_core_pipeline", + "bevy_curve", + "bevy_derive", + "bevy_dev_tools", + "bevy_diagnostic", + "bevy_ecs", + "bevy_extract", + "bevy_feathers", + "bevy_gilrs", + "bevy_gizmos", + "bevy_gizmos_render", + "bevy_gltf", + "bevy_image", + "bevy_input", + "bevy_input_focus", + "bevy_inspector", + "bevy_light", + "bevy_log", + "bevy_material", + "bevy_math", + "bevy_mesh", + "bevy_pbr", + "bevy_picking", + "bevy_platform", + "bevy_post_process", + "bevy_ptr", + "bevy_reflect", + "bevy_remote", + "bevy_render", + "bevy_scene", + "bevy_shader", + "bevy_shape", + "bevy_solari", + "bevy_sprite", + "bevy_sprite_render", + "bevy_state", + "bevy_tasks", + "bevy_text", + "bevy_time", + "bevy_transform", + "bevy_ui", + "bevy_ui_render", + "bevy_ui_widgets", + "bevy_utils", + "bevy_window", + "bevy_winit", + "bevy_world_serialization", +] + +[[package]] +name = "bevy_light" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_curve", + "bevy_ecs", + "bevy_gizmos", + "bevy_image", + "bevy_log", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_shape", + "bevy_transform", + "bevy_utils", + "half", + "smallvec", + "tracing", + "wgpu-types", +] + +[[package]] +name = "bevy_log" +version = "0.20.0-dev" +dependencies = [ + "android_log-sys", + "bevy_app", + "bevy_ecs", + "bevy_platform", + "bevy_utils", + "tracing", + "tracing-chrome", + "tracing-error", + "tracing-log", + "tracing-oslog", + "tracing-subscriber", + "tracing-tracy", + "tracing-wasm", + "tracy-client", +] + +[[package]] +name = "bevy_macro_utils" +version = "0.20.0-dev" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", + "toml_edit", +] + +[[package]] +name = "bevy_material" +version = "0.20.0-dev" +dependencies = [ + "bevy_asset", + "bevy_derive", + "bevy_ecs", + "bevy_material_macros", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_shader", + "bevy_utils", + "encase", + "smallvec", + "thiserror 2.0.21", + "tracing", + "variadics_please", + "wgpu-types", +] + +[[package]] +name = "bevy_material_macros" +version = "0.20.0-dev" +dependencies = [ + "bevy_macro_utils", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_math" +version = "0.20.0-dev" +dependencies = [ + "approx", + "bevy_math", + "bevy_reflect", + "derive_more", + "getrandom 0.4.3", + "glam", + "libm", + "rand 0.10.3", + "serde", + "thiserror 2.0.21", + "variadics_please", +] + +[[package]] +name = "bevy_mesh" +version = "0.20.0-dev" +dependencies = [ + "approx", + "bevy_app", + "bevy_asset", + "bevy_derive", + "bevy_ecs", + "bevy_math", + "bevy_mikktspace", + "bevy_platform", + "bevy_reflect", + "bevy_shape", + "bevy_transform", + "bitflags 2.13.2", + "bytemuck", + "derive_more", + "encase", + "glam", + "half", + "hexasphere", + "serde", + "serde_json", + "thiserror 2.0.21", + "tracing", + "wgpu-types", +] + +[[package]] +name = "bevy_mikktspace" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bff34eb29ff4b8a8688bc7299f14fb6b597461ca80fec03ed7d22939ab33e48f" + +[[package]] +name = "bevy_mobile_example" +version = "0.0.0" +dependencies = [ + "bevy", +] + +[[package]] +name = "bevy_pbr" +version = "0.20.0-dev" +dependencies = [ + "arrayvec", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_extract", + "bevy_gltf", + "bevy_image", + "bevy_light", + "bevy_log", + "bevy_material", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_shape", + "bevy_tasks", + "bevy_transform", + "bevy_utils", + "bitflags 2.13.2", + "bitvec", + "bytemuck", + "derive_more", + "fixedbitset 0.5.7", + "indexmap", + "itertools 0.14.0", + "lz4_flex", + "meshopt", + "metis", + "nonmax", + "offset-allocator", + "range-alloc", + "smallvec", + "static_assertions", + "thiserror 2.0.21", + "tracing", + "wgpu-types", +] + +[[package]] +name = "bevy_picking" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_derive", + "bevy_ecs", + "bevy_input", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_shape", + "bevy_time", + "bevy_transform", + "bevy_window", + "crossbeam-channel", + "tracing", + "uuid", +] + +[[package]] +name = "bevy_platform" +version = "0.20.0-dev" +dependencies = [ + "async-io", + "bytemuck", + "critical-section", + "foldhash 0.2.0", + "futures-channel", + "futures-lite", + "hashbrown 0.17.1", + "js-sys", + "portable-atomic", + "portable-atomic-util", + "rayon", + "serde", + "spin 0.12.3", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-time", + "windows-sys 0.61.2", +] + +[[package]] +name = "bevy_post_process" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_curve", + "bevy_derive", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_utils", + "smallvec", + "thiserror 2.0.21", + "tracing", +] + +[[package]] +name = "bevy_ptr" +version = "0.20.0-dev" + +[[package]] +name = "bevy_reflect" +version = "0.20.0-dev" +dependencies = [ + "assert_type_match", + "bevy_platform", + "bevy_ptr", + "bevy_reflect_derive", + "bevy_utils", + "derive_more", + "disqualified", + "downcast-rs 2.0.2", + "erased-serde", + "foldhash 0.2.0", + "glam", + "hashbrown 0.17.1", + "indexmap", + "inventory", + "petgraph", + "postcard", + "rmp-serde", + "ron", + "serde", + "serde_json", + "smallvec", + "smol_str", + "static_assertions", + "thiserror 2.0.21", + "uuid", + "variadics_please", + "wgpu-types", +] + +[[package]] +name = "bevy_reflect_compile_fail" +version = "0.0.0" +dependencies = [ + "bevy_reflect", + "compile_fail_utils", +] + +[[package]] +name = "bevy_reflect_derive" +version = "0.20.0-dev" +dependencies = [ + "bevy_macro_utils", + "indexmap", + "proc-macro2", + "quote", + "syn 3.0.6", + "uuid", +] + +[[package]] +name = "bevy_remote" +version = "0.20.0-dev" +dependencies = [ + "anyhow", + "async-channel", + "async-io", + "bevy_app", + "bevy_asset", + "bevy_color", + "bevy_derive", + "bevy_dev_tools", + "bevy_diagnostic", + "bevy_ecs", + "bevy_log", + "bevy_platform", + "bevy_reflect", + "bevy_remote", + "bevy_render", + "bevy_tasks", + "bevy_utils", + "http-body-util", + "hyper", + "serde", + "serde_json", + "smol-hyper", +] + +[[package]] +name = "bevy_render" +version = "0.20.0-dev" +dependencies = [ + "async-channel", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_encase_derive", + "bevy_extract", + "bevy_extract_macros", + "bevy_image", + "bevy_log", + "bevy_material", + "bevy_material_macros", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_render_macros", + "bevy_shader", + "bevy_shape", + "bevy_tasks", + "bevy_time", + "bevy_transform", + "bevy_utils", + "bevy_window", + "bitflags 2.13.2", + "bytemuck", + "derive_more", + "downcast-rs 2.0.2", + "encase", + "glam", + "image", + "indexmap", + "itertools 0.14.0", + "js-sys", + "nonmax", + "offset-allocator", + "profiling", + "proptest", + "proptest-derive", + "send_wrapper", + "smallvec", + "static_assertions", + "thiserror 2.0.21", + "tracing", + "tracy-client", + "variadics_please", + "wasm-bindgen", + "weak-table", + "web-sys", + "wgpu", + "wgpu-types", +] + +[[package]] +name = "bevy_render_macros" +version = "0.20.0-dev" +dependencies = [ + "bevy_extract_macros", + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_scene" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_derive", + "bevy_ecs", + "bevy_platform", + "bevy_reflect", + "bevy_scene_macros", + "bevy_utils", + "smallvec", + "thiserror 2.0.21", + "tracing", + "variadics_please", +] + +[[package]] +name = "bevy_scene_macros" +version = "0.20.0-dev" +dependencies = [ + "bevy_ecs_macro_logic", + "bevy_macro_utils", + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_shader" +version = "0.20.0-dev" +dependencies = [ + "bevy_asset", + "bevy_platform", + "bevy_reflect", + "bevy_utils", + "serde", + "thiserror 2.0.21", + "tracing", + "wesl", + "wgpu-types", +] + +[[package]] +name = "bevy_shape" +version = "0.20.0-dev" +dependencies = [ + "approx", + "arrayvec", + "bevy_math", + "bevy_reflect", + "chacha20", + "derive_more", + "rand 0.10.3", + "rand_distr", + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "bevy_solari" +version = "0.20.0-dev" +dependencies = [ + "bevy_anti_alias", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_derive", + "bevy_diagnostic", + "bevy_ecs", + "bevy_image", + "bevy_light", + "bevy_math", + "bevy_mesh", + "bevy_pbr", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_transform", + "bevy_utils", + "bytemuck", + "derive_more", + "tracing", + "wgpu", +] + +[[package]] +name = "bevy_sprite" +version = "0.20.0-dev" +dependencies = [ + "approx", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_derive", + "bevy_ecs", + "bevy_image", + "bevy_log", + "bevy_math", + "bevy_mesh", + "bevy_picking", + "bevy_reflect", + "bevy_text", + "bevy_transform", + "bevy_window", + "radsort", + "tracing", + "wgpu-types", +] + +[[package]] +name = "bevy_sprite_render" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_derive", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_material", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_shape", + "bevy_sprite", + "bevy_text", + "bevy_transform", + "bevy_utils", + "bitflags 2.13.2", + "bytemuck", + "derive_more", + "fixedbitset 0.5.7", + "nonmax", + "smallvec", + "static_assertions", + "tracing", +] + +[[package]] +name = "bevy_state" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_platform", + "bevy_reflect", + "bevy_state_macros", + "bevy_utils", + "log", + "variadics_please", +] + +[[package]] +name = "bevy_state_macros" +version = "0.20.0-dev" +dependencies = [ + "bevy_macro_utils", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bevy_tasks" +version = "0.20.0-dev" +dependencies = [ + "async-channel", + "async-executor", + "async-task", + "atomic-waker", + "bevy_platform", + "concurrent-queue", + "crossbeam-queue", + "derive_more", + "futures-lite", + "heapless 0.9.1", + "web-task", +] + +[[package]] +name = "bevy_text" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_clipboard", + "bevy_color", + "bevy_derive", + "bevy_ecs", + "bevy_image", + "bevy_log", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "bevy_utils", + "parley", + "serde", + "smallvec", + "smol_str", + "swash", + "thiserror 2.0.21", + "tracing", + "wgpu-types", +] + +[[package]] +name = "bevy_time" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_ecs", + "bevy_platform", + "bevy_reflect", + "crossbeam-channel", + "log", + "serde", +] + +[[package]] +name = "bevy_transform" +version = "0.20.0-dev" +dependencies = [ + "approx", + "bevy_app", + "bevy_ecs", + "bevy_math", + "bevy_reflect", + "bevy_tasks", + "bevy_utils", + "derive_more", + "ron", + "serde", + "thiserror 2.0.21", + "tracing", +] + +[[package]] +name = "bevy_ui" +version = "0.20.0-dev" +dependencies = [ + "accesskit", + "bevy_a11y", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_derive", + "bevy_ecs", + "bevy_image", + "bevy_input", + "bevy_input_focus", + "bevy_log", + "bevy_math", + "bevy_picking", + "bevy_platform", + "bevy_reflect", + "bevy_sprite", + "bevy_text", + "bevy_time", + "bevy_transform", + "bevy_utils", + "bevy_window", + "derive_more", + "parley", + "serde", + "smallvec", + "swash", + "taffy", + "thiserror 2.0.21", + "tracing", + "uuid", +] + +[[package]] +name = "bevy_ui_render" +version = "0.20.0-dev" +dependencies = [ + "bevy_a11y", + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_color", + "bevy_core_pipeline", + "bevy_derive", + "bevy_ecs", + "bevy_extract", + "bevy_image", + "bevy_input_focus", + "bevy_math", + "bevy_mesh", + "bevy_platform", + "bevy_reflect", + "bevy_render", + "bevy_shader", + "bevy_sprite", + "bevy_sprite_render", + "bevy_text", + "bevy_transform", + "bevy_ui", + "bevy_utils", + "bytemuck", + "derive_more", + "indexmap", + "smallvec", + "tracing", +] + +[[package]] +name = "bevy_ui_widgets" +version = "0.20.0-dev" +dependencies = [ + "accesskit", + "bevy_a11y", + "bevy_app", + "bevy_camera", + "bevy_ecs", + "bevy_input", + "bevy_input_focus", + "bevy_log", + "bevy_math", + "bevy_picking", + "bevy_platform", + "bevy_reflect", + "bevy_text", + "bevy_time", + "bevy_ui", + "bevy_window", + "parley", + "smol_str", + "web-sys", +] + +[[package]] +name = "bevy_utils" +version = "0.20.0-dev" +dependencies = [ + "async-channel", + "bevy_platform", + "disqualified", + "indexmap", + "serde", + "static_assertions", + "thread_local", +] + +[[package]] +name = "bevy_window" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_color", + "bevy_ecs", + "bevy_image", + "bevy_input", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "log", + "raw-window-handle", + "serde", +] + +[[package]] +name = "bevy_winit" +version = "0.20.0-dev" +dependencies = [ + "accesskit", + "accesskit_winit", + "approx", + "bevy_a11y", + "bevy_android", + "bevy_app", + "bevy_asset", + "bevy_derive", + "bevy_ecs", + "bevy_image", + "bevy_input", + "bevy_input_focus", + "bevy_log", + "bevy_math", + "bevy_platform", + "bevy_reflect", + "bevy_tasks", + "bevy_window", + "bytemuck", + "js-sys", + "tracing", + "wasm-bindgen", + "web-sys", + "wgpu-types", + "winit", + "zbus", +] + +[[package]] +name = "bevy_world_serialization" +version = "0.20.0-dev" +dependencies = [ + "bevy_app", + "bevy_asset", + "bevy_camera", + "bevy_derive", + "bevy_ecs", + "bevy_platform", + "bevy_reflect", + "bevy_transform", + "bevy_utils", + "derive_more", + "postcard", + "rmp-serde", + "ron", + "serde", + "thiserror 2.0.21", + "uuid", +] + +[[package]] +name = "bindgen" +version = "0.72.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895" +dependencies = [ + "bitflags 2.13.2", + "cexpr", + "clang-sys", + "itertools 0.13.0", + "log", + "prettyplease 0.2.37", + "proc-macro2", + "quote", + "regex", + "rustc-hash 2.1.3", + "shlex 1.3.0", + "syn 2.0.119", +] + +[[package]] +name = "bindgen" +version = "0.73.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "787ef8ef523575546b106a58213d6e6b06198a05c2f757258c68a74273670cfa" +dependencies = [ + "bitflags 2.13.2", + "cexpr", + "clang-sys", + "log", + "prettyplease 0.3.0", + "proc-macro2", + "quote", + "regex", + "rustc-hash 2.1.3", + "shlex 2.0.1", + "syn 3.0.6", +] + +[[package]] +name = "bistro" +version = "0.1.0" +dependencies = [ + "argh", + "bevy", + "mipmap_generator", +] + +[[package]] +name = "bit-set" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1" +dependencies = [ + "bit-vec 0.6.3", +] + +[[package]] +name = "bit-set" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" +dependencies = [ + "bit-vec 0.8.0", +] + +[[package]] +name = "bit-set" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34ddef2995421ab6a5c779542c81ee77c115206f4ad9d5a8e05f4ff49716a3dd" +dependencies = [ + "bit-vec 0.9.1", +] + +[[package]] +name = "bit-set" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2f926cc3060f09db9ebc5b52823d85268d24bb917e472c0c4bea35780a7d" +dependencies = [ + "bit-vec 0.9.1", +] + +[[package]] +name = "bit-vec" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" + +[[package]] +name = "bit-vec" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" + +[[package]] +name = "bit-vec" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51" + +[[package]] +name = "bit_field" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e4b40c7323adcfc0a41c4b88143ed58346ff65a288fc144329c5c45e05d70c6" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" +dependencies = [ + "bytemuck", + "serde_core", +] + +[[package]] +name = "bitvec" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddcec3d12c579d40898fe0a9a358a803c23e9c52ca3c425707f81c9436211837" +dependencies = [ + "funty", + "radium", + "tap", + "wyz", +] + +[[package]] +name = "blake3" +version = "1.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae" +dependencies = [ + "arrayvec", + "cc", + "cfg-if", + "constant_time_eq", + "cpufeatures 0.3.1", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "block2" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f" +dependencies = [ + "objc2 0.5.2", +] + +[[package]] +name = "block2" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5" +dependencies = [ + "objc2 0.6.4", +] + +[[package]] +name = "blocking" +version = "1.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a70e4329df6cb94385eed412ec92375c3cdd8a6e502493d1229b6414e4036dfa" +dependencies = [ + "async-channel", + "async-task", + "futures-io", + "futures-lite", + "piper", +] + +[[package]] +name = "bstr" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6bb31b46c14244e20ee9984b11bf5c992b91fb6939fea616e3512c8baecdbe5f" +dependencies = [ + "memchr", + "regex-automata", + "serde_core", +] + +[[package]] +name = "build-easefunction-graphs" +version = "0.0.0" +dependencies = [ + "bevy_curve", + "bevy_math", + "svg", +] + +[[package]] +name = "build-templated-pages" +version = "0.0.0" +dependencies = [ + "bitflags 2.13.2", + "hashbrown 0.17.1", + "serde", + "tera", + "toml_edit", +] + +[[package]] +name = "build-wasm-example" +version = "0.0.0" +dependencies = [ + "clap", + "xshell", +] + +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "by_address" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64fa3c856b712db6612c019f14756e64e4bcea13337a6b33b696333a9eaa2d06" + +[[package]] +name = "bytemuck" +version = "1.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a1f896587b6f2c069c73d2f0913e2d590c3990285cd2f0b6aa02b786b4c679c" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "byteorder-lite" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495" + +[[package]] +name = "bytes" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04" + +[[package]] +name = "caldera_hotel" +version = "0.1.0" +dependencies = [ + "argh", + "bevy", +] + +[[package]] +name = "calloop" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b99da2f8558ca23c71f4fd15dc57c906239752dd27ff3c00a1d56b685b7cbfec" +dependencies = [ + "bitflags 2.13.2", + "log", + "polling", + "rustix 0.38.44", + "slab", + "thiserror 1.0.69", +] + +[[package]] +name = "calloop-wayland-source" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95a66a987056935f7efce4ab5668920b5d0dac4a7c99991a67395f13702ddd20" +dependencies = [ + "calloop", + "rustix 0.38.44", + "wayland-backend", + "wayland-client", +] + +[[package]] +name = "camino" +version = "1.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbbad30e4b4c14a39e3cc8aed085a12a327257c316619c93581e017bc52be591" +dependencies = [ + "serde_core", +] + +[[package]] +name = "cargo-platform" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea" +dependencies = [ + "serde", +] + +[[package]] +name = "cargo_metadata" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037" +dependencies = [ + "camino", + "cargo-platform", + "semver", + "serde", + "serde_json", + "thiserror 1.0.69", +] + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "castaway" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a" +dependencies = [ + "rustversion", +] + +[[package]] +name = "cc" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f360145194ee8e21db5ee7f3fcd4fe52210864c75c985dae33218202c8bbe040" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex 2.0.1", +] + +[[package]] +name = "cesu8" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" + +[[package]] +name = "cexpr" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" +dependencies = [ + "nom 7.1.3", +] + +[[package]] +name = "cfg-expr" +version = "0.20.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe4ece8474b5f766c63426647e7b4b316b67431ade1036a8313cee24a03ae917" +dependencies = [ + "smallvec", + "target-lexicon", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "cfg_aliases" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527" + +[[package]] +name = "chacha20" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.1", + "rand_core 0.10.1", +] + +[[package]] +name = "chrono" +version = "0.4.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327" +dependencies = [ + "iana-time-zone", + "num-traits", + "windows-link", +] + +[[package]] +name = "chrono-tz" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93698b29de5e97ad0ae26447b344c482a7284c737d9ddc5f9e52b74a336671bb" +dependencies = [ + "chrono", + "chrono-tz-build", + "phf 0.11.3", +] + +[[package]] +name = "chrono-tz-build" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c088aee841df9c3041febbb73934cfc39708749bf96dc827e3359cd39ef11b1" +dependencies = [ + "parse-zoneinfo", + "phf 0.11.3", + "phf_codegen", +] + +[[package]] +name = "ci" +version = "0.0.0" +dependencies = [ + "argh", + "xshell", +] + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "clang-sys" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "157a8ba7b480713b56f4c09fd13fc3e0a22a5dfab8097ba61cbc5feef950788a" +dependencies = [ + "glob", + "libc", + "libloading", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_derive" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9c751b79415d4e559e3d1fcf128e09e720eb673a06d26cf6f392d37d75b66e0" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "claxon" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4bfbf56724aa9eca8afa4fcfadeb479e722935bb2a0900c2d37e0cc477af0688" + +[[package]] +name = "clipboard-win" +version = "5.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4" +dependencies = [ + "error-code", +] + +[[package]] +name = "cobs" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" +dependencies = [ + "thiserror 2.0.21", +] + +[[package]] +name = "codespan-reporting" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681" +dependencies = [ + "serde", + "termcolor", + "unicode-width 0.2.2", +] + +[[package]] +name = "color-eyre" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5920befb47832a6d61ee3a3a846565cfa39b331331e68a3b1d1116630f2f26d" +dependencies = [ + "backtrace", + "color-spantrace", + "eyre", + "indenter", + "once_cell", + "owo-colors", + "tracing-error", +] + +[[package]] +name = "color-spantrace" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8b88ea9df13354b55bc7234ebcce36e6ef896aca2e42a15de9e10edce01b427" +dependencies = [ + "once_cell", + "owo-colors", + "tracing-core", + "tracing-error", +] + +[[package]] +name = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + +[[package]] +name = "colorchoice" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" + +[[package]] +name = "colored" +version = "3.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "combine" +version = "4.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e" +dependencies = [ + "bytes", + "memchr", +] + +[[package]] +name = "comma" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55b672471b4e9f9e95499ea597ff64941a309b2cdbffcc46f2cc5e2d971fd335" + +[[package]] +name = "compact_str" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9dfdd1c2274d9aa354115b09dc9a901d6c5576818cdf70d14cae2bdb47df00ab" +dependencies = [ + "castaway", + "cfg-if", + "itoa", + "rustversion", + "ryu", + "static_assertions", +] + +[[package]] +name = "compile_fail_utils" +version = "0.0.0" +dependencies = [ + "ui_test", +] + +[[package]] +name = "concurrent-queue" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" +dependencies = [ + "crossbeam-utils", + "portable-atomic", +] + +[[package]] +name = "console" +version = "0.16.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e96a4956774c13c126a8b5af4daa79384f4d826534c95a02d76afb39e2ab64e3" +dependencies = [ + "encode_unicode", + "libc", + "unicode-width 0.2.2", + "windows-sys 0.61.2", +] + +[[package]] +name = "console_error_panic_hook" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" +dependencies = [ + "cfg-if", + "wasm-bindgen", +] + +[[package]] +name = "const-fnv1a-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32b13ea120a812beba79e34316b3942a857c86ec1593cb34f27bb28272ce2cca" + +[[package]] +name = "const_format" +version = "0.2.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4481a617ad9a412be3b97c5d403fef8ed023103368908b9c50af598ff467cc1e" +dependencies = [ + "const_format_proc_macros", + "konst", +] + +[[package]] +name = "const_format_proc_macros" +version = "0.2.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744" +dependencies = [ + "proc-macro2", + "quote", + "unicode-xid", +] + +[[package]] +name = "const_panic" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9603f79528ece8163c496f8932121cb36cfe46259e9c907bb3d8205139d7caa3" +dependencies = [ + "typewit", +] + +[[package]] +name = "const_soft_float" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87ca1caa64ef4ed453e68bb3db612e51cf1b2f5b871337f0fcab1c8f87cc3dff" + +[[package]] +name = "constant_time_eq" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" + +[[package]] +name = "constgebra" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1aaf9b65849a68662ac6c0810c8893a765c960b907dd7cfab9c4a50bf764fbc" +dependencies = [ + "const_soft_float", +] + +[[package]] +name = "convert_case" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "cookie" +version = "0.18.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a373e3602691c3cdea496d2f0ee5935151e6168fe87739483c463db1b2f2f87" +dependencies = [ + "percent-encoding", + "time", + "version_check", +] + +[[package]] +name = "cookie_store" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fc4bff745c9b4c7fb1e97b25d13153da2bc7796260141df62378998d070207f" +dependencies = [ + "cookie", + "document-features", + "idna", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "time", + "url", +] + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "core-graphics" +version = "0.23.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081" +dependencies = [ + "bitflags 1.3.2", + "core-foundation 0.9.4", + "core-graphics-types", + "foreign-types", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf" +dependencies = [ + "bitflags 1.3.2", + "core-foundation 0.9.4", + "libc", +] + +[[package]] +name = "coreaudio-rs" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d5d7dca3ebcf65a035582c9ad4385371a9d9ee6537474d2a278f4e1e475bb58" +dependencies = [ + "bitflags 2.13.2", + "libc", + "objc2-audio-toolbox", + "objc2-core-audio", + "objc2-core-audio-types", + "objc2-core-foundation", +] + +[[package]] +name = "cpal" +version = "0.17.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8942da362c0f0d895d7cac616263f2f9424edc5687364dfd1d25ef7eba506d7" +dependencies = [ + "alsa", + "coreaudio-rs", + "dasp_sample", + "jni 0.21.1", + "js-sys", + "libc", + "mach2", + "ndk", + "ndk-context", + "num-derive", + "num-traits", + "objc2 0.6.4", + "objc2-audio-toolbox", + "objc2-avf-audio", + "objc2-core-audio", + "objc2-core-audio-types", + "objc2-core-foundation", + "objc2-foundation 0.3.2", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "windows", +] + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "cpufeatures" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566" +dependencies = [ + "libc", +] + +[[package]] +name = "crc32fast" +version = "1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01a7799fd6b852db0e61728dde9a204c423b44d689dbd432522543614b490e78" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "criterion" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3" +dependencies = [ + "alloca", + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "itertools 0.13.0", + "num-traits", + "oorandom", + "page_size", + "plotters", + "rayon", + "regex", + "serde", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea" +dependencies = [ + "cast", + "itertools 0.13.0", +] + +[[package]] +name = "critical-section" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" + +[[package]] +name = "crossbeam-channel" +version = "0.5.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-queue" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03e8bd762f7479489c70ed6c768ddca99d7296857de437a68dcb2a94365b3fae" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6" + +[[package]] +name = "crossterm" +version = "0.29.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b" +dependencies = [ + "bitflags 2.13.2", + "crossterm_winapi", + "derive_more", + "document-features", + "mio", + "parking_lot", + "rustix 1.1.5", + "signal-hook", + "signal-hook-mio", + "winapi", +] + +[[package]] +name = "crossterm_winapi" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b" +dependencies = [ + "winapi", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "csscolorparser" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb2a7d3066da2de787b7f032c736763eb7ae5d355f81a68bab2675a96008b0bf" +dependencies = [ + "lab", + "phf 0.11.3", +] + +[[package]] +name = "ctrlc" +version = "3.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0b1fab2ae45819af2d0731d60f2afe17227ebb1a1538a236da84c93e9a60162" +dependencies = [ + "dispatch2", + "nix 0.31.3", + "windows-sys 0.61.2", +] + +[[package]] +name = "ctt" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c119cc328a986d0bae3a1753941595f1dc6a0f2d938b5f49edf8937bd606fa9" +dependencies = [ + "bytemuck", + "ctt-astcenc", + "ctt-bc7enc-rdo", + "ctt-compressonator", + "ctt-etcpak", + "ctt-intel-texture-compressor", + "ddsfile", + "fast_image_resize", + "flate2", + "half", + "ktx2", + "log", + "miniz_oxide 0.8.9", + "profiling", + "thiserror 2.0.21", + "zstd", +] + +[[package]] +name = "ctt-astcenc" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24a806826f523401c1c8a9afded1c5625f005fd8e6567ceba2fe6254d8c59e3e" +dependencies = [ + "bitflags 2.13.2", + "cc", + "paste", +] + +[[package]] +name = "ctt-bc7enc-rdo" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a4ad8fcbfcafc39a9e02bfb344fd517dd0bcd7adabcc25de19e9703eb3b99a3" +dependencies = [ + "ctt-bc7enc-rdo-prebuilt", + "ispc-build-utils", +] + +[[package]] +name = "ctt-bc7enc-rdo-prebuilt" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f27a2776bbafcc2d335c0621aa9dbd40ecfecdb02a636d3fcd2a2379f96f7472" +dependencies = [ + "ispc-build-utils", +] + +[[package]] +name = "ctt-compressonator" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21eefd5a6f96023adc6bc8c95de1afccded8f958afdbf7e02fa98bf325c41058" +dependencies = [ + "cc", + "thiserror 2.0.21", +] + +[[package]] +name = "ctt-etcpak" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c6025bf0456c4a8c0a693c803eb7368f045f74709adc6b271223ca7f76898ab" +dependencies = [ + "cc", + "paste", +] + +[[package]] +name = "ctt-intel-texture-compressor" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "452985b4223f1a68da0722161ff9a7dbb33bcb32cd30f341b541fd980c58fb26" +dependencies = [ + "cc", + "ctt-intel-texture-compressor-prebuilt", + "ispc-build-utils", +] + +[[package]] +name = "ctt-intel-texture-compressor-prebuilt" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa4031e53991b02e2b9fb903f3bb458ab9a2afcec99320800d4d4092dc43d33c" +dependencies = [ + "ispc-build-utils", +] + +[[package]] +name = "cursor-icon" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f" + +[[package]] +name = "darling" +version = "0.20.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.20.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e" +dependencies = [ + "fnv", + "ident_case", + "proc-macro2", + "quote", + "strsim", + "syn 2.0.119", +] + +[[package]] +name = "darling_macro" +version = "0.20.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" +dependencies = [ + "darling_core", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "dasp_sample" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f" + +[[package]] +name = "data-encoding" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06" + +[[package]] +name = "ddsfile" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8be425797f9962624aba78dee473dad28c15999e6ee6feb28ad3ee7928a3bc5b" +dependencies = [ + "bitflags 2.13.2", + "byteorder", + "enum-primitive-derive", + "num-traits", +] + +[[package]] +name = "deltae" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5729f5117e208430e437df2f4843f5e5952997175992d1414f94c57d61e270b4" + +[[package]] +name = "deranged" +version = "0.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c" + +[[package]] +name = "derive_more" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134" +dependencies = [ + "derive_more-impl", +] + +[[package]] +name = "derive_more-impl" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb" +dependencies = [ + "convert_case", + "proc-macro2", + "quote", + "rustc_version", + "syn 2.0.119", + "unicode-xid", +] + +[[package]] +name = "deunicode" +version = "1.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abd57806937c9cc163efc8ea3910e00a62e2aeb0b8119f1793a978088f8f6b04" + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", +] + +[[package]] +name = "dioxus-cli-config" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "322d10f47effebd85ee0662a2cb083ff920d40dd6295a4afd8cfa4f9bc2e05c6" + +[[package]] +name = "dioxus-core" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b232228ada232c0adc151e41ebd9ef70cc04683db097fa0dc6015979fa01722" +dependencies = [ + "anyhow", + "const_format", + "dioxus-core-types", + "futures-channel", + "futures-util", + "generational-box", + "longest-increasing-subsequence", + "rustc-hash 2.1.3", + "rustversion", + "serde", + "slab", + "slotmap", + "subsecond", + "tracing", +] + +[[package]] +name = "dioxus-core-types" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96007ed6cbad951dfed82d83c581aabd95bc591f351f5666d454ddbe7845b324" + +[[package]] +name = "dioxus-devtools" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "434cebb282b3f820a341582ebfd37dab907d5a25c3eeafd87802468afcd2a959" +dependencies = [ + "dioxus-cli-config", + "dioxus-core", + "dioxus-devtools-types", + "dioxus-signals", + "serde", + "serde_json", + "subsecond", + "thiserror 2.0.21", + "tracing", + "tungstenite", +] + +[[package]] +name = "dioxus-devtools-types" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfd6f3475e38c93be245a664a9ce11679a8f2b99832620705cf7837f42aa39ce" +dependencies = [ + "dioxus-core", + "serde", + "subsecond-types", +] + +[[package]] +name = "dioxus-signals" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95d85e36fcaf7abdc986836801bf248776da7d5961f5fac65fdbf5ed491afb4f" +dependencies = [ + "dioxus-core", + "futures-channel", + "futures-util", + "generational-box", + "parking_lot", + "rustc-hash 2.1.3", + "tracing", + "warnings", +] + +[[package]] +name = "dispatch" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b" + +[[package]] +name = "dispatch2" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38" +dependencies = [ + "bitflags 2.13.2", + "block2 0.6.2", + "libc", + "objc2 0.6.4", +] + +[[package]] +name = "displaydoc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "disqualified" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e90a5dd66beeca277ae954f8055b02a712792b6b6b43f2bc2f92b0b7d8291614" + +[[package]] +name = "dlib" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a" +dependencies = [ + "libloading", +] + +[[package]] +name = "dlss_wgpu" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6d49749f048ae6512153417e1ca603417620f6024132a4bb6d7a52f138a8bea" +dependencies = [ + "ash", + "bindgen 0.73.2", + "bitflags 2.13.2", + "cc", + "thiserror 2.0.21", + "uuid", + "wgpu", +] + +[[package]] +name = "document-features" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61" +dependencies = [ + "litrs", +] + +[[package]] +name = "downcast-rs" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2" + +[[package]] +name = "downcast-rs" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "117240f60069e65410b3ae1bb213295bd828f707b5bec6596a1afc8793ce0cbc" + +[[package]] +name = "dpi" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76" + +[[package]] +name = "either" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34" + +[[package]] +name = "embedded-io" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" + +[[package]] +name = "embedded-io" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" + +[[package]] +name = "ena" +version = "0.14.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eabffdaee24bd1bf95c5ef7cec31260444317e72ea56c4c91750e8b7ee58d5f1" +dependencies = [ + "log", +] + +[[package]] +name = "encase" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdf6312703f02e0625e1750eadf556054b6da5e44960a3a771e9127cb357dbd8" +dependencies = [ + "const_panic", + "encase_derive", + "thiserror 2.0.21", +] + +[[package]] +name = "encase_derive" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8429e24f02acf09b0fb3c4560c329a1a79fab14bbb9c2d632c073d0a61b0816a" +dependencies = [ + "encase_derive_impl", +] + +[[package]] +name = "encase_derive_impl" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ac3bf06563c72a9b64bc4d8da00ebcabd1d776ea4526c3b1461697142fe340f" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + +[[package]] +name = "encoding_rs" +version = "0.8.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "endi" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099" + +[[package]] +name = "enum-primitive-derive" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba7795da175654fe16979af73f81f26a8ea27638d8d9823d317016888a63dc4c" +dependencies = [ + "num-traits", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "enumflags2" +version = "0.7.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef" +dependencies = [ + "enumflags2_derive", + "serde", +] + +[[package]] +name = "enumflags2_derive" +version = "0.7.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "enumn" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f9ed6b3789237c8a0c1c505af1c7eb2c560df6186f01b098c3a1064ea532f38" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "erased-serde" +version = "0.4.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2add8a07dd6a8d93ff627029c51de145e12686fbc36ecb298ac22e74cf02dec" +dependencies = [ + "serde", + "serde_core", + "typeid", +] + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "error-code" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7" + +[[package]] +name = "errors" +version = "0.0.0" +dependencies = [ + "bevy", +] + +[[package]] +name = "euclid" +version = "0.22.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1a05365e3b1c6d1650318537c7460c6923f1abdd272ad6842baa2b509957a06" +dependencies = [ + "num-traits", +] + +[[package]] +name = "event-listener" +version = "5.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2" +dependencies = [ + "parking", + "pin-project-lite", +] + +[[package]] +name = "event-listener-strategy" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93" +dependencies = [ + "event-listener", + "pin-project-lite", +] + +[[package]] +name = "example-showcase" +version = "0.0.0" +dependencies = [ + "clap", + "pbr", + "regex", + "toml_edit", + "xshell", +] + +[[package]] +name = "export-content" +version = "0.1.0" +dependencies = [ + "miette", + "ratatui", + "regex", + "serde", + "serde_yml", + "thiserror 2.0.21", +] + +[[package]] +name = "exr" +version = "1.74.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "711fe42c9964295e01ee3fba3f9fe0e1d24b98886950d68efe81b1c76e21adf3" +dependencies = [ + "bit_field", + "half", + "lebe", + "miniz_oxide 0.8.9", + "num-complex", + "pulp", + "smallvec", + "zune-inflate", +] + +[[package]] +name = "extended" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af9673d8203fcb076b19dfd17e38b3d4ae9f44959416ea532ce72415a6020365" + +[[package]] +name = "eyre" +version = "0.6.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08309dbcc659c5549a24ddb9b27027640641b282ef5768267c7e675558986a3" +dependencies = [ + "autocfg", + "indenter", + "once_cell", +] + +[[package]] +name = "fancy-regex" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b95f7c0680e4142284cf8b22c14a476e87d61b004a3a0861872b32ef7ead40a2" +dependencies = [ + "bit-set 0.5.3", + "regex", +] + +[[package]] +name = "fast_image_resize" +version = "6.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9c50201dc184ba6553da1695aac20a042efffbe2d84542cee31917c86c3ab1e" +dependencies = [ + "bytemuck", + "cfg-if", + "document-features", + "image", + "num-traits", + "thiserror 2.0.21", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "fax" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a" + +[[package]] +name = "fdeflate" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "file-id" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1fc6a637b6dc58414714eddd9170ff187ecb0933d4c7024d1abbd23a3cc26e9" +dependencies = [ + "windows-sys 0.60.2", +] + +[[package]] +name = "filedescriptor" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e40758ed24c9b2eeb76c35fb0aebc66c626084edd827e07e1552279814c6682d" +dependencies = [ + "libc", + "thiserror 1.0.69", + "winapi", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "finl_unicode" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80bb028c8b4148c9ee0cca68fcd9add6044e81d3619f48577ddf13a263d047a2" + +[[package]] +name = "fixedbitset" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" + +[[package]] +name = "fixedbitset" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" + +[[package]] +name = "flate2" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb" +dependencies = [ + "crc32fast", + "miniz_oxide 0.9.1", + "zlib-rs", +] + +[[package]] +name = "float-cmp" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b09cf3155332e944990140d967ff5eceb70df778b34f77d8075db46e4704e6d8" +dependencies = [ + "num-traits", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "font-types" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8eb065f3251655b3c90e22e5e363f310fc5332fb3402e37bbc94752283248f6" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "fontique" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6688bc1294fe7117d788937b6c53480169b29c566954af490830d4c09da9516a" +dependencies = [ + "hashbrown 0.17.1", + "linebender_resource_handle", + "memmap2", + "objc2 0.6.4", + "objc2-core-foundation", + "objc2-core-text", + "objc2-foundation 0.3.2", + "parlance", + "read-fonts", + "roxmltree", + "smallvec", + "windows", + "windows-core", + "yeslogic-fontconfig-sys", +] + +[[package]] +name = "foreign-types" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" +dependencies = [ + "foreign-types-macros", + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-macros" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "foreign-types-shared" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" + +[[package]] +name = "form_urlencoded" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "fsevent-sys" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2" +dependencies = [ + "libc", +] + +[[package]] +name = "funty" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" + +[[package]] +name = "futures-channel" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4" +dependencies = [ + "futures-core", +] + +[[package]] +name = "futures-core" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e" + +[[package]] +name = "futures-io" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed" + +[[package]] +name = "futures-lite" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad" +dependencies = [ + "fastrand", + "futures-core", + "futures-io", + "parking", + "pin-project-lite", +] + +[[package]] +name = "futures-macro" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "futures-task" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd" + +[[package]] +name = "futures-timer" +version = "3.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af43fadb8a98512d547e37b4e92e0ced13e205c061b87b4623eff01d918d6968" +dependencies = [ + "gloo-timers", + "send_wrapper", +] + +[[package]] +name = "futures-util" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc" +dependencies = [ + "futures-core", + "futures-macro", + "futures-task", + "pin-project-lite", + "slab", +] + +[[package]] +name = "generational-box" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8b2dc9b873cd1a8adb80aa5dcef9a8205f781a8a313d5ffb867248cb3bcb764" +dependencies = [ + "parking_lot", + "tracing", +] + +[[package]] +name = "generator" +version = "0.8.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "54ade96dc9003043bce7c035c85a9df5a858bfb2039c5a2e6fdf00f324f6c551" +dependencies = [ + "cc", + "cfg-if", + "libc", + "log", + "rustversion", + "windows-link", + "windows-result", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "gethostname" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8" +dependencies = [ + "rustix 1.1.5", + "windows-link", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + +[[package]] +name = "getrandom" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "r-efi 6.0.0", + "rand_core 0.10.1", + "wasm-bindgen", +] + +[[package]] +name = "gif" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159" +dependencies = [ + "color_quant", + "weezl", +] + +[[package]] +name = "gilrs" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "902fb00d3f6398e635be22e5c837b303c501835cca7ac11a47bba138f7aafdd8" +dependencies = [ + "fnv", + "gilrs-core", + "log", + "uuid", + "vec_map", +] + +[[package]] +name = "gilrs-core" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc7f0ce6237abcc0523f2a5502b1e3fe5802daaae47ac14e166fe49551301ea9" +dependencies = [ + "inotify", + "js-sys", + "libc", + "libudev-sys", + "log", + "nix 0.31.3", + "objc2-core-foundation", + "objc2-io-kit", + "uuid", + "vec_map", + "wasm-bindgen", + "web-sys", + "windows", +] + +[[package]] +name = "gimli" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7" + +[[package]] +name = "gl_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d" +dependencies = [ + "khronos_api", + "log", + "xml-rs", +] + +[[package]] +name = "glam" +version = "0.33.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35b4e837a1d133645d1dcf283e146a4b9901e390a1c13545f959cfed3a72f24f" +dependencies = [ + "approx", + "bytemuck", + "encase", + "libm", + "mint", + "rand 0.10.3", + "serde_core", +] + +[[package]] +name = "glob" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b" + +[[package]] +name = "globset" +version = "0.4.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e47d37d2ae4464254884b60ab7071be2b876a9c35b696bd018ddcc76847309cd" +dependencies = [ + "aho-corasick", + "bstr", + "log", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "globwalk" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bf760ebf69878d9fd8f110c89703d90ce35095324d1f1edcb595c63945ee757" +dependencies = [ + "bitflags 2.13.2", + "ignore", + "walkdir", +] + +[[package]] +name = "gloo-timers" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "482ce8a491a501da4cd806bd190275363d674f2845005c6ddbd5d3e1dd54495d" +dependencies = [ + "futures-channel", + "futures-core", + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "glow" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29038e1c483364cc6bb3cf78feee1816002e127c331a1eec55a4d202b9e1adb5" +dependencies = [ + "js-sys", + "slotmap", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "gltf" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3ce1918195723ce6ac74e80542c5a96a40c2b26162c1957a5cd70799b8cacf7" +dependencies = [ + "base64 0.13.1", + "byteorder", + "gltf-json", + "image", + "lazy_static", + "serde_json", + "urlencoding", +] + +[[package]] +name = "gltf-derive" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14070e711538afba5d6c807edb74bcb84e5dbb9211a3bf5dea0dfab5b24f4c51" +dependencies = [ + "inflections", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "gltf-json" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6176f9d60a7eab0a877e8e96548605dedbde9190a7ae1e80bbcc1c9af03ab14" +dependencies = [ + "gltf-derive", + "serde", + "serde_derive", + "serde_json", +] + +[[package]] +name = "glutin_wgl_sys" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c4ee00b289aba7a9e5306d57c2d05499b2e5dc427f84ac708bd2c090212cf3e" +dependencies = [ + "gl_generator", +] + +[[package]] +name = "gpu-allocator" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51255ea7cfaadb6c5f1528d43e92a82acb2b96c43365989a28b2d44ee38f8795" +dependencies = [ + "ash", + "hashbrown 0.16.1", + "log", + "presser", + "thiserror 2.0.21", + "windows", +] + +[[package]] +name = "guillotiere" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b17e70c989c36bad147b27a58d148c0741c51448aa5653436547323e524d0ab" +dependencies = [ + "euclid", +] + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "bytemuck", + "cfg-if", + "crunchy", + "num-traits", + "serde", + "zerocopy", +] + +[[package]] +name = "harfrust" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c03d949a14aa089bbb282f7dd76a498a7f684428e4257202efc119ec010376f9" +dependencies = [ + "bitflags 2.13.2", + "bytemuck", + "read-fonts", + "smallvec", +] + +[[package]] +name = "hash32" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" +dependencies = [ + "byteorder", +] + +[[package]] +name = "hash32" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606" +dependencies = [ + "byteorder", +] + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash 0.1.5", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash 0.2.0", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash 0.2.0", + "rayon", + "serde", + "serde_core", +] + +[[package]] +name = "heapless" +version = "0.7.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f" +dependencies = [ + "atomic-polyfill", + "hash32 0.2.1", + "rustc_version", + "serde", + "spin 0.9.9", + "stable_deref_trait", +] + +[[package]] +name = "heapless" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1edcd5a338e64688fbdcb7531a846cfd3476a54784dcb918a0844682bc7ada5" +dependencies = [ + "hash32 0.3.1", + "portable-atomic", + "stable_deref_trait", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hermit-abi" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284" + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hexasphere" +version = "19.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "163385eff5a0cf606ebe2c10b3a44ab02f4306e83fbd068a64f5e1d72a3049ac" +dependencies = [ + "constgebra", + "glam", + "tinyvec", +] + +[[package]] +name = "hound" +version = "3.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62adaabb884c94955b19907d60019f4e145d091c75345379e70d1ee696f7854f" + +[[package]] +name = "http" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "http-body" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca2a8f2913ee65f60facd6a5905613afaa448497a0230cc41ce022d93290bc2c" +dependencies = [ + "bytes", + "http", +] + +[[package]] +name = "http-body-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c" +dependencies = [ + "bytes", + "futures-core", + "http", + "http-body", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "httpdate" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" + +[[package]] +name = "humansize" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6cb51c9a029ddc91b07a787f1d86b53ccfa49b0e86688c946ebe8d3555685dd7" +dependencies = [ + "libm", +] + +[[package]] +name = "hyper" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27b501faa50e7a26c3d3560ca625132f4078a17771f4810baf70475ae48cbe43" +dependencies = [ + "atomic-waker", + "bytes", + "futures-channel", + "futures-core", + "http", + "http-body", + "httparse", + "httpdate", + "itoa", + "pin-project-lite", + "smallvec", + "tokio", + "want", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "icu_collections" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "532b11722e350ab6bf916ba6eb0efe3ee54b932666afec989465f9243fe6dd60" +dependencies = [ + "icu_collections", + "icu_locale_core", + "icu_locale_data", + "icu_provider", + "potential_utf", + "tinystr", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6" +dependencies = [ + "displaydoc", + "litemap", + "serde", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_locale_data" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c5f1d16b4c3a2642d3a719f18f6b06070ab0aef246a6418130c955ae08aa831" + +[[package]] +name = "icu_normalizer" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599" +dependencies = [ + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a" + +[[package]] +name = "icu_properties" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec" +dependencies = [ + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af" + +[[package]] +name = "icu_provider" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614" +dependencies = [ + "displaydoc", + "icu_locale_core", + "serde", + "stable_deref_trait", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_segmenter" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a807a7488f3f758629ae86d99d9d30dce24da2fb2945d74c80a4f4a62c71db73" +dependencies = [ + "icu_collections", + "icu_locale", + "icu_provider", + "icu_segmenter_data", + "potential_utf", + "utf8_iter", + "zerovec", +] + +[[package]] +name = "icu_segmenter_data" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ebbb7321d9e21d25f5660366cb6c08201d0175898a3a6f7a41ee9685af21c80" + +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + +[[package]] +name = "idna" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "ignore" +version = "0.4.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b009b6744c1445efd7244084e25e498636412effb6760b55067553baa925cc7" +dependencies = [ + "crossbeam-deque", + "globset", + "log", + "memchr", + "regex-automata", + "same-file", + "walkdir", + "winapi-util", +] + +[[package]] +name = "image" +version = "0.25.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a" +dependencies = [ + "bytemuck", + "byteorder-lite", + "color_quant", + "exr", + "gif", + "image-webp", + "moxcms", + "num-traits", + "png", + "qoi", + "tiff", + "zune-core 0.5.3", + "zune-jpeg 0.5.15", +] + +[[package]] +name = "image-webp" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3" +dependencies = [ + "byteorder-lite", + "quick-error 2.0.1", +] + +[[package]] +name = "indenter" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5" + +[[package]] +name = "indexmap" +version = "2.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855" +dependencies = [ + "equivalent", + "hashbrown 0.17.1", + "serde", + "serde_core", +] + +[[package]] +name = "indicatif" +version = "0.18.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9433806cd6b4ec1aba79c021c7e4c58fb4c3b9977c085062e611ac929998fb0c" +dependencies = [ + "console", + "portable-atomic", + "unicode-width 0.2.2", + "unit-prefix", + "web-time", +] + +[[package]] +name = "indoc" +version = "2.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706" +dependencies = [ + "rustversion", +] + +[[package]] +name = "inflections" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a257582fdcde896fd96463bf2d40eefea0580021c0712a0e2b028b60b47a837a" + +[[package]] +name = "inotify" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cc00ea907cab49550b7da656f80ebb97be1b997d931fbcd28d39734e17ce592" +dependencies = [ + "bitflags 2.13.2", + "inotify-sys", + "libc", +] + +[[package]] +name = "inotify-sys" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c033f80b2c113cdf91ab7a33faa9cbc014726dcad99880c8609af2a370edf37d" +dependencies = [ + "libc", +] + +[[package]] +name = "instability" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6778b0196eefee7df739db78758e5cf9b37412268bfa5650bfeed028aed20d9c" +dependencies = [ + "darling", + "indoc", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "intel_tex_2" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7980d359170e7da4bc2421aa74c49d338a3153313e006d732a3430f1af375a60" +dependencies = [ + "ispc_rt", +] + +[[package]] +name = "inventory" +version = "0.3.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b" +dependencies = [ + "rustversion", +] + +[[package]] +name = "is_ci" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45" + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" + +[[package]] +name = "ispc-build-utils" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4cda913ddb107b9bb5c46769855e3849e62daa52fc7e70de0080ca4e6cfd030" +dependencies = [ + "find-msvc-tools", +] + +[[package]] +name = "ispc_rt" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a396f76fd253fab9945bb4c6080f515d0c4036bc30219462d199b58886fd37b4" +dependencies = [ + "libc", + "num_cpus", +] + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "jni" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97" +dependencies = [ + "cesu8", + "cfg-if", + "combine", + "jni-sys 0.3.1", + "log", + "thiserror 1.0.69", + "walkdir", + "windows-sys 0.45.0", +] + +[[package]] +name = "jni" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498" +dependencies = [ + "cfg-if", + "combine", + "jni-macros", + "jni-sys 0.4.1", + "log", + "simd_cesu8", + "thiserror 2.0.21", + "walkdir", + "windows-link", +] + +[[package]] +name = "jni-macros" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3" +dependencies = [ + "proc-macro2", + "quote", + "rustc_version", + "simd_cesu8", + "syn 2.0.119", +] + +[[package]] +name = "jni-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258" +dependencies = [ + "jni-sys 0.4.1", +] + +[[package]] +name = "jni-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2" +dependencies = [ + "jni-sys-macros", +] + +[[package]] +name = "jni-sys-macros" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" +dependencies = [ + "quote", + "syn 2.0.119", +] + +[[package]] +name = "jobserver" +version = "0.1.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3" +dependencies = [ + "getrandom 0.4.3", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5" +dependencies = [ + "cfg-if", + "futures-util", + "wasm-bindgen", +] + +[[package]] +name = "kasuari" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bde5057d6143cc94e861d90f591b9303d6716c6b9602309150bd068853c10899" +dependencies = [ + "hashbrown 0.16.1", + "portable-atomic", + "thiserror 2.0.21", +] + +[[package]] +name = "keccak" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653" +dependencies = [ + "cpufeatures 0.2.17", +] + +[[package]] +name = "khronos-egl" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76" +dependencies = [ + "libc", + "libloading", + "pkg-config", +] + +[[package]] +name = "khronos_api" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc" + +[[package]] +name = "konst" +version = "0.2.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "128133ed7824fcd73d6e7b17957c5eb7bacb885649bd8c69708b2331a10bcefb" +dependencies = [ + "konst_macro_rules", +] + +[[package]] +name = "konst_macro_rules" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4933f3f57a8e9d9da04db23fb153356ecaf00cbd14aee46279c33dc80925c37" + +[[package]] +name = "kqueue" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d763e5b24120b4ddf50de6c92308156765aabfbbccebf401da7cff2d70a41ea" +dependencies = [ + "kqueue-sys", + "libc", +] + +[[package]] +name = "kqueue-sys" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07293a4e297ac234359b510362495713f75ea345d5307140414f20c69ffeb087" +dependencies = [ + "bitflags 2.13.2", + "libc", +] + +[[package]] +name = "ktx2" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d50be8a24c37debdf3170be6ca396d5b5b165f37f94837891adac735ca416b8" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "lab" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf36173d4167ed999940f804952e6b08197cae5ad5d572eb4db150ce8ad5d58f" + +[[package]] +name = "lalrpop" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98a80a963123205c7157323c99611bc4abb65dcbd62ef46dc4bac74a3941bc75" +dependencies = [ + "ascii-canvas", + "bit-set 0.9.1", + "ena", + "itertools 0.14.0", + "lalrpop-util", + "petgraph", + "regex", + "regex-syntax", + "sha3", + "string_cache", + "term", + "unicode-xid", + "walkdir", +] + +[[package]] +name = "lalrpop-util" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "884f3e747ed2dcee867cda1b0c31a048f9e20de2d916a248949319921a2e666e" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" + +[[package]] +name = "lebe" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8" + +[[package]] +name = "levenshtein" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db13adb97ab515a3691f56e4dbab09283d0b86cb45abd991d8634a9d6f501760" + +[[package]] +name = "lewton" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "777b48df9aaab155475a83a7df3070395ea1ac6902f5cd062b8f2b028075c030" +dependencies = [ + "byteorder", + "ogg", + "tinyvec", +] + +[[package]] +name = "lexical" +version = "7.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bc8a009b2ff1f419ccc62706f04fe0ca6e67b37460513964a3dfdb919bb37d6" +dependencies = [ + "lexical-core", +] + +[[package]] +name = "lexical-core" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594" +dependencies = [ + "lexical-parse-float", + "lexical-parse-integer", + "lexical-util", + "lexical-write-float", + "lexical-write-integer", +] + +[[package]] +name = "lexical-parse-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56" +dependencies = [ + "lexical-parse-integer", + "lexical-util", +] + +[[package]] +name = "lexical-parse-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lexical-util" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17" + +[[package]] +name = "lexical-write-float" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361" +dependencies = [ + "lexical-util", + "lexical-write-integer", +] + +[[package]] +name = "lexical-write-integer" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df" +dependencies = [ + "lexical-util", +] + +[[package]] +name = "lhash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "744a4c881f502e98c2241d2e5f50040ac73b30194d64452bb6260393b53f0dc9" + +[[package]] +name = "libc" +version = "0.2.189" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + +[[package]] +name = "libredox" +version = "0.1.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61ff90caf6077a803a240f62fdbe88645a890bbca49ef8174c3cb0404362171d" +dependencies = [ + "bitflags 2.13.2", + "libc", + "plain", + "redox_syscall 0.9.4", +] + +[[package]] +name = "libudev-sys" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c8469b4a23b962c1396b9b451dda50ef5b283e8dd309d69033475fa9b334324" +dependencies = [ + "libc", + "pkg-config", +] + +[[package]] +name = "libyml" +version = "0.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3302702afa434ffa30847a83305f0a69d6abd74293b6554c18ec85c7ef30c980" +dependencies = [ + "anyhow", + "version_check", +] + +[[package]] +name = "line-clipping" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e752191d037c44ad111a8caa762921926658402f01cc1253f7bef2020ece4f5e" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "linebender_resource_handle" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4a5ff6bcca6c4867b1c4fd4ef63e4db7436ef363e0ad7531d1558856bae64f4" + +[[package]] +name = "linux-raw-sys" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "litemap" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae" + +[[package]] +name = "litrs" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092" + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6" + +[[package]] +name = "logos" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb2c55a318a87600ea870ff8c2012148b44bf18b74fad48d0f835c38c7d07c5f" +dependencies = [ + "logos-derive", +] + +[[package]] +name = "logos-codegen" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58b3ffaa284e1350d017a57d04ada118c4583cf260c8fb01e0fe28a2e9cf8970" +dependencies = [ + "fnv", + "proc-macro2", + "quote", + "regex-automata", + "regex-syntax", + "syn 2.0.119", +] + +[[package]] +name = "logos-derive" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52d3a9855747c17eaf4383823f135220716ab49bea5fbea7dd42cc9a92f8aa31" +dependencies = [ + "logos-codegen", +] + +[[package]] +name = "longest-increasing-subsequence" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b3bd0dd2cd90571056fdb71f6275fada10131182f84899f4b2a916e565d81d86" + +[[package]] +name = "loom" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca" +dependencies = [ + "cfg-if", + "generator", + "scoped-tls", + "tracing", + "tracing-subscriber", +] + +[[package]] +name = "lru" +version = "0.18.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef9ac18847474e638e3702b76c65d4eb93428471a74778ef0f1be711717f89b5" +dependencies = [ + "hashbrown 0.17.1", +] + +[[package]] +name = "lz4_flex" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ef0d4ed8669f8f8826eb00dc878084aa8f253506c4fd5e8f58f5bce72ddb97e" +dependencies = [ + "twox-hash", +] + +[[package]] +name = "mac_address" +version = "1.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0aeb26bf5e836cc1c341c8106051b573f1766dfa05aa87f0b98be5e51b02303" +dependencies = [ + "nix 0.29.0", + "winapi", +] + +[[package]] +name = "mach-dxcompiler-rs" +version = "0.1.6+2026.09.16-48d5a66.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "699d5b85d279d172f6ea742c6c47342fdd7c388872cea2e137e2c6721ef2e6d6" +dependencies = [ + "lhash", +] + +[[package]] +name = "mach2" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a1b95cd5421ec55b445b5ae102f5ea0e768de1f82bd3001e11f426c269c3aea" +dependencies = [ + "libc", +] + +[[package]] +name = "matchers" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memfd" +version = "0.6.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57804b2c9b69967f1536a56f86297e367a33b19e98852ed624b84551cdbc0d90" +dependencies = [ + "rustix 1.1.5", +] + +[[package]] +name = "memmap2" +version = "0.9.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0" +dependencies = [ + "libc", +] + +[[package]] +name = "memmem" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a64a92489e2744ce060c349162be1c5f33c6969234104dbd99ddb5feb08b8c15" + +[[package]] +name = "memoffset" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +dependencies = [ + "autocfg", +] + +[[package]] +name = "meshopt" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e01e77ead21976b3a9f01ec1724f766923da74f0726364e2b0f425658935d71a" +dependencies = [ + "bitflags 2.13.2", + "cc", + "float-cmp", + "thiserror 2.0.21", +] + +[[package]] +name = "metis" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3653658399c092e0912b25c591e9dc89bae5c1db377b85c52011991f8b628ceb" +dependencies = [ + "metis-sys", +] + +[[package]] +name = "metis-sys" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "769ee6be814b21c52afcc631f07051f578487d642f3e89a45f2a086fd94fffa9" +dependencies = [ + "cc", +] + +[[package]] +name = "miette" +version = "7.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f98efec8807c63c752b5bd61f862c165c115b0a35685bdcfd9238c7aeb592b7" +dependencies = [ + "backtrace", + "backtrace-ext", + "cfg-if", + "miette-derive", + "owo-colors", + "supports-color", + "supports-hyperlinks", + "supports-unicode", + "terminal_size", + "textwrap", + "unicode-width 0.1.14", +] + +[[package]] +name = "miette-derive" +version = "7.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db5b29714e950dbb20d5e6f74f9dcec4edbcc1067bb7f8ed198c097b8c1a818b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "miniz_oxide" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "mint" +version = "0.5.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e53debba6bda7a793e5f99b8dacf19e626084f525f7829104ba9898f367d85ff" + +[[package]] +name = "mio" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b18443e9c262bfe8fa82f51666e2642c53393f7e5c27b3e1aeab922cff5b9d8" +dependencies = [ + "libc", + "log", + "wasi", + "windows-sys 0.61.2", +] + +[[package]] +name = "mipmap_generator" +version = "0.1.0" +dependencies = [ + "anyhow", + "argh", + "bevy", + "fast_image_resize", + "futures-lite", + "image", + "intel_tex_2", + "tracing", + "zstd", +] + +[[package]] +name = "moxcms" +version = "0.7.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac9557c559cd6fc9867e122e20d2cbefc9ca29d80d027a8e39310920ed2f0a97" +dependencies = [ + "num-traits", + "pxfm", +] + +[[package]] +name = "mutants" +version = "0.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc0287524726960e07b119cebd01678f852f147742ae0d925e6a520dca956126" + +[[package]] +name = "naga" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a616d2fb8c89516ac2723a581f69d6c18576046bed761bd6b305e5618e6ae130" +dependencies = [ + "arrayvec", + "bit-set 0.10.0", + "bitflags 2.13.2", + "cfg-if", + "cfg_aliases", + "codespan-reporting", + "half", + "hashbrown 0.17.1", + "indexmap", + "libm", + "log", + "naga-types", + "num-traits", + "once_cell", + "petgraph", + "rustc-hash 1.1.0", + "spirv", + "thiserror 2.0.21", + "unicode-ident", +] + +[[package]] +name = "naga-types" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49" +dependencies = [ + "hashbrown 0.17.1", + "indexmap", + "rustc-hash 1.1.0", + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "ndk" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4" +dependencies = [ + "bitflags 2.13.2", + "jni-sys 0.3.1", + "log", + "ndk-sys", + "num_enum", + "raw-window-handle", + "thiserror 1.0.69", +] + +[[package]] +name = "ndk-context" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b" + +[[package]] +name = "ndk-sys" +version = "0.6.0+11769913" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873" +dependencies = [ + "jni-sys 0.3.1", +] + +[[package]] +name = "new_debug_unreachable" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086" + +[[package]] +name = "nix" +version = "0.29.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46" +dependencies = [ + "bitflags 2.13.2", + "cfg-if", + "cfg_aliases", + "libc", + "memoffset", +] + +[[package]] +name = "nix" +version = "0.31.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d" +dependencies = [ + "bitflags 2.13.2", + "cfg-if", + "cfg_aliases", + "libc", +] + +[[package]] +name = "no_std_library" +version = "0.1.0" +dependencies = [ + "bevy", +] + +[[package]] +name = "noise" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6da45c8333f2e152fc665d78a380be060eb84fad8ca4c9f7ac8ca29216cff0cc" +dependencies = [ + "num-traits", + "rand 0.8.8", + "rand_xorshift 0.3.0", +] + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "nom" +version = "8.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405" +dependencies = [ + "memchr", +] + +[[package]] +name = "nonmax" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "610a5acd306ec67f907abe5567859a3c693fb9886eb1f012ab8f2a47bef3db51" + +[[package]] +name = "notify" +version = "8.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d3d07927151ff8575b7087f245456e549fea62edf0ec4e565a5ee50c8402bc3" +dependencies = [ + "bitflags 2.13.2", + "fsevent-sys", + "inotify", + "kqueue", + "libc", + "log", + "mio", + "notify-types", + "walkdir", + "windows-sys 0.60.2", +] + +[[package]] +name = "notify-debouncer-full" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c02b49179cfebc9932238d04d6079912d26de0379328872846118a0fa0dbb302" +dependencies = [ + "file-id", + "log", + "notify", + "notify-types", + "walkdir", +] + +[[package]] +name = "notify-types" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42b8cfee0e339a0337359f3c88165702ac6e600dc01c0cc9579a92d62b08477a" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "ntapi" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3b335231dfd352ffb0f8017f3b6027a4917f7df785ea2143d8af2adc66980ae" +dependencies = [ + "winapi", +] + +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "num-bigint" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "bytemuck", + "num-traits", +] + +[[package]] +name = "num-conv" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441" + +[[package]] +name = "num-derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "num-integer" +version = "0.1.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" +dependencies = [ + "num-bigint", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "num_cpus" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b" +dependencies = [ + "hermit-abi", + "libc", +] + +[[package]] +name = "num_enum" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26" +dependencies = [ + "num_enum_derive", + "rustversion", +] + +[[package]] +name = "num_enum_derive" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "num_threads" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9" +dependencies = [ + "libc", +] + +[[package]] +name = "objc-sys" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310" + +[[package]] +name = "objc2" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804" +dependencies = [ + "objc-sys", + "objc2-encode", +] + +[[package]] +name = "objc2" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f" +dependencies = [ + "objc2-encode", +] + +[[package]] +name = "objc2-app-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "libc", + "objc2 0.5.2", + "objc2-core-data", + "objc2-core-image", + "objc2-foundation 0.2.2", + "objc2-quartz-core 0.2.2", +] + +[[package]] +name = "objc2-app-kit" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c" +dependencies = [ + "bitflags 2.13.2", + "objc2 0.6.4", + "objc2-core-graphics", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-audio-toolbox" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6948501a91121d6399b79abaa33a8aa4ea7857fe019f341b8c23ad6e81b79b08" +dependencies = [ + "bitflags 2.13.2", + "libc", + "objc2 0.6.4", + "objc2-core-audio", + "objc2-core-audio-types", + "objc2-core-foundation", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-avf-audio" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be" +dependencies = [ + "objc2 0.6.4", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-cloud-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-core-location", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-contacts" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5ff520e9c33812fd374d8deecef01d4a840e7b41862d849513de77e44aa4889" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-core-audio" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1eebcea8b0dbff5f7c8504f3107c68fc061a3eb44932051c8cf8a68d969c3b2" +dependencies = [ + "dispatch2", + "objc2 0.6.4", + "objc2-core-audio-types", + "objc2-core-foundation", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-core-audio-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a89f2ec274a0cf4a32642b2991e8b351a404d290da87bb6a9a9d8632490bd1c" +dependencies = [ + "bitflags 2.13.2", + "objc2 0.6.4", +] + +[[package]] +name = "objc2-core-data" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-core-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" +dependencies = [ + "bitflags 2.13.2", + "block2 0.6.2", + "dispatch2", + "libc", + "objc2 0.6.4", +] + +[[package]] +name = "objc2-core-graphics" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807" +dependencies = [ + "bitflags 2.13.2", + "dispatch2", + "objc2 0.6.4", + "objc2-core-foundation", + "objc2-io-surface", +] + +[[package]] +name = "objc2-core-image" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55260963a527c99f1819c4f8e3b47fe04f9650694ef348ffd2227e8196d34c80" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", + "objc2-metal 0.2.2", +] + +[[package]] +name = "objc2-core-location" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "000cfee34e683244f284252ee206a27953279d370e309649dc3ee317b37e5781" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.2", + "objc2-contacts", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-core-text" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d" +dependencies = [ + "bitflags 2.13.2", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] +name = "objc2-foundation" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "dispatch", + "libc", + "objc2 0.5.2", +] + +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags 2.13.2", + "block2 0.6.2", + "libc", + "objc2 0.6.4", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-io-kit" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33fafba39597d6dc1fb709123dfa8289d39406734be322956a69f0931c73bb15" +dependencies = [ + "bitflags 2.13.2", + "libc", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-io-surface" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d" +dependencies = [ + "bitflags 2.13.2", + "objc2 0.6.4", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-link-presentation" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1a1ae721c5e35be65f01a03b6d2ac13a54cb4fa70d8a5da293d7b0020261398" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.2", + "objc2-app-kit 0.2.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-metal" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-metal" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794" +dependencies = [ + "bitflags 2.13.2", + "block2 0.6.2", + "objc2 0.6.4", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", + "objc2-metal 0.2.2", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f" +dependencies = [ + "bitflags 2.13.2", + "objc2 0.6.4", + "objc2-core-foundation", + "objc2-core-graphics", + "objc2-foundation 0.3.2", + "objc2-metal 0.3.2", +] + +[[package]] +name = "objc2-symbols" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a684efe3dec1b305badae1a28f6555f6ddd3bb2c2267896782858d5a78404dc" +dependencies = [ + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-ui-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-cloud-kit", + "objc2-core-data", + "objc2-core-image", + "objc2-core-location", + "objc2-foundation 0.2.2", + "objc2-link-presentation", + "objc2-quartz-core 0.2.2", + "objc2-symbols", + "objc2-uniform-type-identifiers", + "objc2-user-notifications", +] + +[[package]] +name = "objc2-uniform-type-identifiers" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44fa5f9748dbfe1ca6c0b79ad20725a11eca7c2218bceb4b005cb1be26273bfe" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-user-notifications" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3" +dependencies = [ + "bitflags 2.13.2", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-core-location", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "object" +version = "0.37.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +dependencies = [ + "memchr", +] + +[[package]] +name = "offset-allocator" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e234d535da3521eb95106f40f0b73483d80bfb3aacf27c40d7e2b72f1a3e00a2" +dependencies = [ + "log", + "nonmax", +] + +[[package]] +name = "ogg" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6951b4e8bf21c8193da321bcce9c9dd2e13c858fe078bf9054a288b419ae5d6e" +dependencies = [ + "byteorder", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "once_cell_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "openssl-probe" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" + +[[package]] +name = "orbclient" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5df339f526ea9a60e371768d50efc2f2508c7203290731565d1f7a6f71d21747" +dependencies = [ + "libc", + "libredox", +] + +[[package]] +name = "ordered-float" +version = "4.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951" +dependencies = [ + "num-traits", +] + +[[package]] +name = "ordered-float" +version = "5.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c860fd3227ca4ac3cc032e2cd20cba3f02ccdf4b610538f8ee6584d56bb62e96" +dependencies = [ + "num-traits", +] + +[[package]] +name = "ordered-stream" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50" +dependencies = [ + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "os_pipe" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "owned_ttf_parser" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b" +dependencies = [ + "ttf-parser", +] + +[[package]] +name = "owo-colors" +version = "4.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c45bb4a6ae1280ec0803b1ef9d3455eb50f01efbbe1447ab020f1d54fba9d8" + +[[package]] +name = "page_size" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "palette" +version = "0.7.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddeed8580d347d2abf3dcf06a5f0b3dc020258338526b277847cd4248a70fc64" +dependencies = [ + "approx", + "libm", + "palette_derive", + "palette_math", +] + +[[package]] +name = "palette_derive" +version = "0.7.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88537020289b719d81be994ccf1bbf4990f477e2f69ee52fe3e45f43a02e56be" +dependencies = [ + "by_address", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "palette_math" +version = "0.7.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e6eb142958d64335fb0e345c5b9ead2ecd6fc438c307e9d7d3c4fd428dbaf12" +dependencies = [ + "libm", +] + +[[package]] +name = "parking" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba" + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall 0.5.18", + "smallvec", + "windows-link", +] + +[[package]] +name = "parlance" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b6937eda350acc1a5d05872c3cbf99fe78619c269096e2be3d4a350058639d5" + +[[package]] +name = "parley" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22d2ff88bd3f7d68d1d9b09c7e6209f9a8e8c05088295140a2bcf2e9b17038c5" +dependencies = [ + "fontique", + "harfrust", + "hashbrown 0.17.1", + "icu_normalizer", + "icu_properties", + "icu_segmenter", + "linebender_resource_handle", + "parlance", + "parley_data", + "skrifa", +] + +[[package]] +name = "parley_data" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1567535334d6ba2d3cde19221ba9a7bd0fabb3cbd99046ddfb10ae061cfcc889" +dependencies = [ + "icu_properties", +] + +[[package]] +name = "parse-zoneinfo" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f2a05b18d44e2957b88f96ba460715e295bc1d7510468a2f3d3b44535d26c24" +dependencies = [ + "regex", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + +[[package]] +name = "pbr" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5827dfa0d69b6c92493d6c38e633bbaa5937c153d0d7c28bf12313f8c6d514" +dependencies = [ + "crossbeam-channel", + "libc", + "winapi", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "pest" +version = "2.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45d3aca230fad2e6f6317ca0a72724338c4960cb97168a85cdee66df4a9a21a8" +dependencies = [ + "memchr", + "ucd-trie", +] + +[[package]] +name = "pest_derive" +version = "2.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "284b60557f2c4a2e72ad3f2d34d42685a2fa4a6a61d0d2a10c0ae2a5e916c2cf" +dependencies = [ + "pest", + "pest_generator", +] + +[[package]] +name = "pest_generator" +version = "2.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d9d1f08a115309ee99268cf85e5228e0e56aa9caf8841ec12866b6be07c3109" +dependencies = [ + "pest", + "pest_meta", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "pest_meta" +version = "2.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed93ba1a9ffcca32130a5188701c81c0c49cf00d4b7c5007d5148951d743adcb" +dependencies = [ + "pest", +] + +[[package]] +name = "petgraph" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455" +dependencies = [ + "fixedbitset 0.5.7", + "hashbrown 0.15.5", + "indexmap", + "serde", + "serde_derive", +] + +[[package]] +name = "phf" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078" +dependencies = [ + "phf_macros 0.11.3", + "phf_shared 0.11.3", +] + +[[package]] +name = "phf" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "010378780309880b08997fae13be7834dba947d36393bd372f2b1556deb2a2f6" +dependencies = [ + "phf_macros 0.14.0", + "phf_shared 0.14.0", + "serde", +] + +[[package]] +name = "phf_codegen" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a" +dependencies = [ + "phf_generator 0.11.3", + "phf_shared 0.11.3", +] + +[[package]] +name = "phf_generator" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d" +dependencies = [ + "phf_shared 0.11.3", + "rand 0.8.8", +] + +[[package]] +name = "phf_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100" +dependencies = [ + "fastrand", + "phf_shared 0.14.0", +] + +[[package]] +name = "phf_macros" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216" +dependencies = [ + "phf_generator 0.11.3", + "phf_shared 0.11.3", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "phf_macros" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5fa8d0ca26d424d27630da600c6624696e7dec8bf7b3b492b383c5dc49e5e085" +dependencies = [ + "phf_generator 0.14.0", + "phf_shared 0.14.0", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "phf_shared" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5" +dependencies = [ + "siphasher", +] + +[[package]] +name = "phf_shared" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266" +dependencies = [ + "siphasher", +] + +[[package]] +name = "phf_shared" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89" +dependencies = [ + "siphasher", +] + +[[package]] +name = "pin-project" +version = "1.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924" +dependencies = [ + "pin-project-internal", +] + +[[package]] +name = "pin-project-internal" +version = "1.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "piper" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1" +dependencies = [ + "atomic-waker", + "fastrand", + "futures-io", +] + +[[package]] +name = "pkg-config" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" + +[[package]] +name = "plain" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" + +[[package]] +name = "plotters" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747" +dependencies = [ + "num-traits", + "plotters-backend", + "plotters-svg", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "plotters-backend" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a" + +[[package]] +name = "plotters-svg" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670" +dependencies = [ + "plotters-backend", +] + +[[package]] +name = "png" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61" +dependencies = [ + "bitflags 2.13.2", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide 0.8.9", +] + +[[package]] +name = "polling" +version = "3.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi", + "pin-project-lite", + "rustix 1.1.5", + "windows-sys 0.61.2", +] + +[[package]] +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" +dependencies = [ + "critical-section", +] + +[[package]] +name = "portable-atomic-util" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "postcard" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" +dependencies = [ + "cobs", + "embedded-io 0.4.0", + "embedded-io 0.6.1", + "heapless 0.7.17", + "serde", +] + +[[package]] +name = "potential_utf" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661" +dependencies = [ + "serde_core", + "writeable", + "zerovec", +] + +[[package]] +name = "powerfmt" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "precomputed-hash" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" + +[[package]] +name = "presser" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa" + +[[package]] +name = "prettydiff" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac17546d82912e64874e3d5b40681ce32eac4e5834344f51efcf689ff1550a65" +dependencies = [ + "owo-colors", +] + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn 2.0.119", +] + +[[package]] +name = "prettyplease" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bfe0f4c752e450fc2faf62654f1c134747922825d5b04ca717b8874f41a40c0" +dependencies = [ + "proc-macro2", + "syn 3.0.6", +] + +[[package]] +name = "proc-macro-crate" +version = "3.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" +dependencies = [ + "toml_edit", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "profiling" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5" +dependencies = [ + "profiling-procmacros", + "tracing", +] + +[[package]] +name = "profiling-procmacros" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4488a4a36b9a4ba6b9334a32a39971f77c1436ec82c38707bce707699cc3bbcb" +dependencies = [ + "quote", + "syn 2.0.119", +] + +[[package]] +name = "proptest" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744" +dependencies = [ + "bit-set 0.8.0", + "bit-vec 0.8.0", + "bitflags 2.13.2", + "num-traits", + "rand 0.9.5", + "rand_chacha 0.9.0", + "rand_xorshift 0.4.0", + "regex-syntax", + "rusty-fork", + "tempfile", + "unarray", +] + +[[package]] +name = "proptest-derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c57924a81864dddafba92e1bf92f9bf82f97096c44489548a60e888e1547549b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "pulp" +version = "0.22.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "046aa45b989642ec2e4717c8e72d677b13edd831a4d3b6cf37d9a3e54912496a" +dependencies = [ + "bytemuck", + "cfg-if", + "libm", + "num-complex", + "paste", + "pulp-wasm-simd-flag", + "raw-cpuid", + "reborrow", + "version_check", +] + +[[package]] +name = "pulp-wasm-simd-flag" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d8f70e07b9c3962945a74e59ca1c511bba65b6419468acc217c457d93f3c740" + +[[package]] +name = "pxfm" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea" + +[[package]] +name = "qoi" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "quick-error" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" + +[[package]] +name = "quick-error" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3" + +[[package]] +name = "quick-xml" +version = "0.38.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quick-xml" +version = "0.41.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e660451e55124f798a69a5af3f49ccfbefbd41910eefd25caf2393e1f3473ec1" +dependencies = [ + "memchr", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "radium" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" + +[[package]] +name = "radsort" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "019b4b213425016d7d84a153c4c73afb0946fbb4840e4eece7ba8848b9d6da22" + +[[package]] +name = "rand" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c" +dependencies = [ + "libc", + "rand_chacha 0.3.1", + "rand_core 0.6.4", +] + +[[package]] +name = "rand" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41" +dependencies = [ + "rand_chacha 0.9.0", + "rand_core 0.9.5", +] + +[[package]] +name = "rand" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af" +dependencies = [ + "chacha20", + "getrandom 0.4.3", + "rand_core 0.10.1", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", +] + +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", +] + +[[package]] +name = "rand_core" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" + +[[package]] +name = "rand_distr" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d431c2703ccf129de4d45253c03f49ebb22b97d6ad79ee3ecfc7e3f4862c1d8" +dependencies = [ + "num-traits", + "rand 0.10.3", +] + +[[package]] +name = "rand_xorshift" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f" +dependencies = [ + "rand_core 0.6.4", +] + +[[package]] +name = "rand_xorshift" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a" +dependencies = [ + "rand_core 0.9.5", +] + +[[package]] +name = "range-alloc" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08" + +[[package]] +name = "ratatui" +version = "0.30.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3274ba0a2c5e1bcad2a2005d20f4dc59dad26b2eb0940fb094500dba4099d57d" +dependencies = [ + "instability", + "ratatui-core", + "ratatui-crossterm", + "ratatui-macros", + "ratatui-termina", + "ratatui-termwiz", + "ratatui-widgets", + "serde", +] + +[[package]] +name = "ratatui-core" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbb175c433c8e28a809d1f5773a2ae96e68c0ce40db865cbab1020bf33ae479c" +dependencies = [ + "bitflags 2.13.2", + "compact_str", + "critical-section", + "hashbrown 0.17.1", + "itertools 0.14.0", + "kasuari", + "lru", + "palette", + "serde", + "strum", + "thiserror 2.0.21", + "unicode-segmentation", + "unicode-truncate", + "unicode-width 0.2.2", +] + +[[package]] +name = "ratatui-crossterm" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "567584a3b0e6a8203c23de40b4861497266725eb5363dbfd18a1edd603cca9f0" +dependencies = [ + "cfg-if", + "crossterm", + "instability", + "ratatui-core", +] + +[[package]] +name = "ratatui-macros" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed7dc68daa7498a43e4d68e0eb078427e10c38fbcfbb1e42d955f1fa2140d814" +dependencies = [ + "ratatui-core", + "ratatui-widgets", +] + +[[package]] +name = "ratatui-termina" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0bf912d9e66f057a759d92e386a280ea886b352ab757d6ac4d653c7ed2c43c2" +dependencies = [ + "instability", + "ratatui-core", + "termina", +] + +[[package]] +name = "ratatui-termwiz" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "faf03e0380b7744054d6cb74224fe3adf062a029754933f575ca1e3b4c2ce977" +dependencies = [ + "ratatui-core", + "termwiz", +] + +[[package]] +name = "ratatui-widgets" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "66e3d19bcc9130ca376277d93b60767ff121ace3be06f5f95f81dd68956407d1" +dependencies = [ + "bitflags 2.13.2", + "hashbrown 0.17.1", + "indoc", + "instability", + "itertools 0.14.0", + "line-clipping", + "ratatui-core", + "serde", + "strum", + "time", + "unicode-segmentation", + "unicode-width 0.2.2", +] + +[[package]] +name = "raw-cpuid" +version = "11.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "raw-window-handle" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539" + +[[package]] +name = "raw-window-metal" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40d213455a5f1dc59214213c7330e074ddf8114c9a42411eb890c767357ce135" +dependencies = [ + "objc2 0.6.4", + "objc2-core-foundation", + "objc2-foundation 0.3.2", + "objc2-quartz-core 0.3.2", +] + +[[package]] +name = "rayon" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "read-fonts" +version = "0.41.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709" +dependencies = [ + "bytemuck", + "font-types", + "once_cell", +] + +[[package]] +name = "reborrow" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03251193000f4bd3b042892be858ee50e8b3719f2b08e5833ac4353724632430" + +[[package]] +name = "rectangle-pack" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0d463f2884048e7153449a55166f91028d5b0ea53c79377099ce4e8cf0cf9bb" + +[[package]] +name = "redox_syscall" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "redox_syscall" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "737970939a87c6fa31e7acad13307bccbb017a073b695b6089a2c484f929e20e" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "renderdoc-sys" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832" + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.17", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "rmp" +version = "0.8.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c" +dependencies = [ + "num-traits", +] + +[[package]] +name = "rmp-serde" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155" +dependencies = [ + "rmp", + "serde", +] + +[[package]] +name = "rodio" +version = "0.22.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0a536bb79db59098ef71a4dd4246c02eb87b316deceb1b68e0cde7167ec01eb" +dependencies = [ + "claxon", + "cpal", + "dasp_sample", + "hound", + "lewton", + "num-rational", + "symphonia", + "thiserror 2.0.21", + "tracing", +] + +[[package]] +name = "ron" +version = "0.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81116b9531d61eabc41aeb228e4b6b2435bcca3233b98cf3b3077d4e6e9debb3" +dependencies = [ + "bitflags 2.13.2", + "once_cell", + "serde", + "serde_derive", + "typeid", + "unicode-ident", +] + +[[package]] +name = "roxmltree" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb" +dependencies = [ + "memchr", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b74b56ffa8bb2830709a538c2cbcae9aa062db0d2a42563bfb09bdaae44020eb" + +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + +[[package]] +name = "rustc-hash" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d" + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustfix" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82fa69b198d894d84e23afde8e9ab2af4400b2cba20d6bf2b428a8b01c222c5a" +dependencies = [ + "serde", + "serde_json", + "thiserror 1.0.69", + "tracing", +] + +[[package]] +name = "rustix" +version = "0.38.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" +dependencies = [ + "bitflags 2.13.2", + "errno", + "libc", + "linux-raw-sys 0.4.15", + "windows-sys 0.59.0", +] + +[[package]] +name = "rustix" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "891efababe418670775f199f0d233d84843c227a0949a883ce15b37c78d6629d" +dependencies = [ + "bitflags 2.13.2", + "errno", + "libc", + "linux-raw-sys 0.12.1", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustls" +version = "0.23.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634" +dependencies = [ + "log", + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-native-certs" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dab5152771c58876a2146916e53e35057e1a4dfa2b9df0f0305b07f611fdea4d" +dependencies = [ + "openssl-probe", + "rustls-pki-types", + "schannel", + "security-framework", +] + +[[package]] +name = "rustls-pki-types" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96" +dependencies = [ + "zeroize", +] + +[[package]] +name = "rustls-platform-verifier" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1167586491e2b18b8bfbb293e8180ec17c201c4f076d7cb3070ca964e7598f98" +dependencies = [ + "core-foundation 0.10.1", + "core-foundation-sys", + "jni 0.22.4", + "log", + "once_cell", + "rustls", + "rustls-native-certs", + "rustls-platform-verifier-android", + "rustls-webpki", + "security-framework", + "security-framework-sys", + "webpki-root-certs", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustls-platform-verifier-android" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eec689c0bc40ff2458a5977b6619cb718087084a18e02a131c599b62d05e1a5f" + +[[package]] +name = "rustls-webpki" +version = "0.103.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2" +dependencies = [ + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f" + +[[package]] +name = "rusty-fork" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2" +dependencies = [ + "fnv", + "quick-error 1.2.3", + "tempfile", + "wait-timeout", +] + +[[package]] +name = "ruzstd" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5ff0cc5e135c8870a775d3320910cd9b564ec036b4dc0b8741629020be63f01" +dependencies = [ + "twox-hash", +] + +[[package]] +name = "ryu" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "schannel" +version = "0.1.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "sctk-adwaita" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6277f0217056f77f1d8f49f2950ac6c278c0d607c45f5ee99328d792ede24ec" +dependencies = [ + "ab_glyph", + "log", + "memmap2", + "smithay-client-toolkit", + "tiny-skia", +] + +[[package]] +name = "security-framework" +version = "3.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d" +dependencies = [ + "bitflags 2.13.2", + "core-foundation 0.10.1", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" +dependencies = [ + "serde", + "serde_core", +] + +[[package]] +name = "send_wrapper" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73" + +[[package]] +name = "seq-macro" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "serde_repr" +version = "0.1.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "serde_spanned" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26" +dependencies = [ + "serde_core", +] + +[[package]] +name = "serde_test" +version = "1.0.177" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f901ee573cab6b3060453d2d5f0bae4e6d628c23c0a962ff9b5f1d7c8d4f1ed" +dependencies = [ + "serde", +] + +[[package]] +name = "serde_yml" +version = "0.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59e2dd588bf1597a252c3b920e0143eb99b0f76e4e082f4c92ce34fbc9e71ddd" +dependencies = [ + "indexmap", + "itoa", + "libyml", + "memchr", + "ryu", + "serde", + "version_check", +] + +[[package]] +name = "sha1" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "digest", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "digest", +] + +[[package]] +name = "sha3" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77fd7028345d415a4034cf8777cd4f8ab1851274233b45f84e3d955502d93874" +dependencies = [ + "digest", + "keccak", +] + +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "signal-hook" +version = "0.3.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2" +dependencies = [ + "libc", + "signal-hook-registry", +] + +[[package]] +name = "signal-hook-mio" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc" +dependencies = [ + "libc", + "mio", + "signal-hook", +] + +[[package]] +name = "signal-hook-registry" +version = "1.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" +dependencies = [ + "errno", + "libc", +] + +[[package]] +name = "simd-adler32" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea" + +[[package]] +name = "simd_cesu8" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520" +dependencies = [ + "rustc_version", + "simdutf8", +] + +[[package]] +name = "simdutf8" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" + +[[package]] +name = "siphasher" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256" + +[[package]] +name = "skrifa" +version = "0.44.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819ab7d62b1d3e72d9d9dea5650bac30424f9111364bb94928dbf5ecad1baa68" +dependencies = [ + "bytemuck", + "read-fonts", +] + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "slotmap" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038" +dependencies = [ + "serde", + "version_check", +] + +[[package]] +name = "slug" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "882a80f72ee45de3cc9a5afeb2da0331d58df69e4e7d8eeb5d3c7784ae67e724" +dependencies = [ + "deunicode", + "wasm-bindgen", +] + +[[package]] +name = "smallvec" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e" +dependencies = [ + "serde", +] + +[[package]] +name = "smithay-client-toolkit" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3457dea1f0eb631b4034d61d4d8c32074caa6cd1ab2d59f2327bd8461e2c0016" +dependencies = [ + "bitflags 2.13.2", + "calloop", + "calloop-wayland-source", + "cursor-icon", + "libc", + "log", + "memmap2", + "rustix 0.38.44", + "thiserror 1.0.69", + "wayland-backend", + "wayland-client", + "wayland-csd-frame", + "wayland-cursor", + "wayland-protocols", + "wayland-protocols-wlr", + "wayland-scanner", + "xkeysym", +] + +[[package]] +name = "smol-hyper" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7428a49d323867702cd12b97b08a6b0104f39ec13b49117911f101271321bc1a" +dependencies = [ + "async-executor", + "async-io", + "futures-io", + "hyper", + "pin-project-lite", +] + +[[package]] +name = "smol_str" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead" +dependencies = [ + "serde", +] + +[[package]] +name = "spanned" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c92d4b0c055fde758f086eb4a6e73410247df8a3837fd606d2caeeaf72aa566d" +dependencies = [ + "anyhow", + "bstr", + "color-eyre", +] + +[[package]] +name = "spin" +version = "0.9.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e" +dependencies = [ + "lock_api", +] + +[[package]] +name = "spin" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0134f9043ed38b087ac4f7d4af44c79e2c9e5094421fe3164f435ce585953b10" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "spirv" +version = "0.4.0+sdk-1.4.341.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9571ea910ebd84c86af4b3ed27f9dbdc6ad06f17c5f96146b2b671e2976744f" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "stackfuture" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "115beb9c69db2393ff10b75a1b8587a51716e5551d015001e55320ed279d32f9" +dependencies = [ + "const_panic", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "strict-num" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731" + +[[package]] +name = "string_cache" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a18596f8c785a729f2819c0f6a7eae6ebeebdfffbfe4214ae6b087f690e31901" +dependencies = [ + "new_debug_unreachable", + "parking_lot", + "phf_shared 0.13.1", + "precomputed-hash", +] + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "strum" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd" +dependencies = [ + "strum_macros", +] + +[[package]] +name = "strum_macros" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "subsecond" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d350d5788fa94d560d92269266a50efc77b036bfca6675e420b64df7b3211f37" +dependencies = [ + "js-sys", + "libc", + "libloading", + "memfd", + "memmap2", + "serde", + "subsecond-types", + "thiserror 2.0.21", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "subsecond-types" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcf32d66269b5fbb8558334e8d22b657b2f7af0dd2ef56c231541099a862e464" +dependencies = [ + "serde", +] + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "supports-color" +version = "3.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c64fc7232dd8d2e4ac5ce4ef302b1d81e0b80d055b9d77c7c4f51f6aa4c867d6" +dependencies = [ + "is_ci", +] + +[[package]] +name = "supports-hyperlinks" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e396b6523b11ccb83120b115a0b7366de372751aa6edf19844dfb13a6af97e91" + +[[package]] +name = "supports-unicode" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7401a30af6cb5818bb64852270bb722533397edcfc7344954a38f420819ece2" + +[[package]] +name = "svg" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94afda9cd163c04f6bee8b4bf2501c91548deae308373c436f36aeff3cf3c4a3" + +[[package]] +name = "swash" +version = "0.2.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c2499c2d826531388872b2268718aed907a39bd785ab0dcfe57fab26283f92e" +dependencies = [ + "skrifa", + "yazi", + "zeno", +] + +[[package]] +name = "symphonia" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5773a4c030a19d9bfaa090f49746ff35c75dfddfa700df7a5939d5e076a57039" +dependencies = [ + "lazy_static", + "symphonia-bundle-flac", + "symphonia-bundle-mp3", + "symphonia-codec-aac", + "symphonia-codec-pcm", + "symphonia-codec-vorbis", + "symphonia-core", + "symphonia-format-isomp4", + "symphonia-format-ogg", + "symphonia-format-riff", + "symphonia-metadata", +] + +[[package]] +name = "symphonia-bundle-flac" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c91565e180aea25d9b80a910c546802526ffd0072d0b8974e3ebe59b686c9976" +dependencies = [ + "log", + "symphonia-core", + "symphonia-metadata", + "symphonia-utils-xiph", +] + +[[package]] +name = "symphonia-bundle-mp3" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4872dd6bb56bf5eac799e3e957aa1981086c3e613b27e0ac23b176054f7c57ed" +dependencies = [ + "lazy_static", + "log", + "symphonia-core", + "symphonia-metadata", +] + +[[package]] +name = "symphonia-codec-aac" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c263845aa86881416849c1729a54c7f55164f8b96111dba59de46849e73a790" +dependencies = [ + "lazy_static", + "log", + "symphonia-core", +] + +[[package]] +name = "symphonia-codec-pcm" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e89d716c01541ad3ebe7c91ce4c8d38a7cf266a3f7b2f090b108fb0cb031d95" +dependencies = [ + "log", + "symphonia-core", +] + +[[package]] +name = "symphonia-codec-vorbis" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f025837c309cd69ffef572750b4a2257b59552c5399a5e49707cc5b1b85d1c73" +dependencies = [ + "log", + "symphonia-core", + "symphonia-utils-xiph", +] + +[[package]] +name = "symphonia-core" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea00cc4f79b7f6bb7ff87eddc065a1066f3a43fe1875979056672c9ef948c2af" +dependencies = [ + "arrayvec", + "bitflags 1.3.2", + "bytemuck", + "lazy_static", + "log", +] + +[[package]] +name = "symphonia-format-isomp4" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "243739585d11f81daf8dac8d9f3d18cc7898f6c09a259675fc364b382c30e0a5" +dependencies = [ + "encoding_rs", + "log", + "symphonia-core", + "symphonia-metadata", + "symphonia-utils-xiph", +] + +[[package]] +name = "symphonia-format-ogg" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b4955c67c1ed3aa8ae8428d04ca8397fbef6a19b2b051e73b5da8b1435639cb" +dependencies = [ + "log", + "symphonia-core", + "symphonia-metadata", + "symphonia-utils-xiph", +] + +[[package]] +name = "symphonia-format-riff" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2d7c3df0e7d94efb68401d81906eae73c02b40d5ec1a141962c592d0f11a96f" +dependencies = [ + "extended", + "log", + "symphonia-core", + "symphonia-metadata", +] + +[[package]] +name = "symphonia-metadata" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36306ff42b9ffe6e5afc99d49e121e0bd62fe79b9db7b9681d48e29fa19e6b16" +dependencies = [ + "encoding_rs", + "lazy_static", + "log", + "symphonia-core", +] + +[[package]] +name = "symphonia-utils-xiph" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee27c85ab799a338446b68eec77abf42e1a6f1bb490656e121c6e27bfbab9f16" +dependencies = [ + "symphonia-core", + "symphonia-metadata", +] + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "synstructure" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "sysinfo" +version = "0.39.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2071df9448915b71c4fe6d25deaf1c22f12bd234f01540b77312bb8e41361e6" +dependencies = [ + "libc", + "memchr", + "ntapi", + "objc2-core-foundation", + "objc2-io-kit", + "windows", +] + +[[package]] +name = "system-deps" +version = "7.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "396a35feb67335377e0251fcbc1092fc85c484bd4e3a7a54319399da127796e7" +dependencies = [ + "cfg-expr", + "heck", + "pkg-config", + "toml", + "version-compare", +] + +[[package]] +name = "taffy" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "639627c87f43b9181c811f40a6296409e093a17bc761214cba3c15df74f86b99" +dependencies = [ + "arrayvec", + "serde", + "slotmap", + "smallvec", +] + +[[package]] +name = "tap" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" + +[[package]] +name = "target-lexicon" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca" + +[[package]] +name = "tempfile" +version = "3.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" +dependencies = [ + "fastrand", + "getrandom 0.4.3", + "once_cell", + "rustix 1.1.5", + "windows-sys 0.61.2", +] + +[[package]] +name = "tera" +version = "1.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8004bca281f2d32df3bacd59bc67b312cb4c70cea46cbd79dbe8ac5ed206722" +dependencies = [ + "chrono", + "chrono-tz", + "globwalk", + "humansize", + "lazy_static", + "percent-encoding", + "pest", + "pest_derive", + "rand 0.8.8", + "regex", + "serde", + "serde_json", + "slug", + "unicode-segmentation", +] + +[[package]] +name = "term" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8c27177b12a6399ffc08b98f76f7c9a1f4fe9fc967c784c5a071fa8d93cf7e1" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "termina" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9048a889effe34a5cddee0af7f53285198b16dca3be510858d38dfdb3e62a04e" +dependencies = [ + "bitflags 2.13.2", + "parking_lot", + "rustix 1.1.5", + "signal-hook", + "windows-sys 0.61.2", +] + +[[package]] +name = "terminal_size" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874" +dependencies = [ + "rustix 1.1.5", + "windows-sys 0.61.2", +] + +[[package]] +name = "terminfo" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4ea810f0692f9f51b382fff5893887bb4580f5fa246fde546e0b13e7fcee662" +dependencies = [ + "fnv", + "nom 7.1.3", + "phf 0.11.3", + "phf_codegen", +] + +[[package]] +name = "termios" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "411c5bf740737c7918b8b1fe232dca4dc9f8e754b8ad5e20966814001ed0ac6b" +dependencies = [ + "libc", +] + +[[package]] +name = "termwiz" +version = "0.23.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4676b37242ccbd1aabf56edb093a4827dc49086c0ffd764a5705899e0f35f8f7" +dependencies = [ + "anyhow", + "base64 0.22.1", + "bitflags 2.13.2", + "fancy-regex", + "filedescriptor", + "finl_unicode", + "fixedbitset 0.4.2", + "hex", + "lazy_static", + "libc", + "log", + "memmem", + "nix 0.29.0", + "num-derive", + "num-traits", + "ordered-float 4.6.0", + "pest", + "pest_derive", + "phf 0.11.3", + "sha2", + "signal-hook", + "siphasher", + "terminfo", + "termios", + "thiserror 1.0.69", + "ucd-trie", + "unicode-segmentation", + "vtparse", + "wezterm-bidi", + "wezterm-blob-leases", + "wezterm-color-types", + "wezterm-dynamic", + "wezterm-input-types", + "winapi", +] + +[[package]] +name = "textwrap" +version = "0.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057" +dependencies = [ + "unicode-linebreak", + "unicode-width 0.2.2", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl 2.0.21", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "thread_local" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ad99c4c6d32803332c548b1af0540b357b3f5fc0be8f6c6bfe8b2e6ae784070" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "tiff" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af9605de7fee8d9551863fd692cce7637f548dbd9db9180fcc07ccc6d26c336f" +dependencies = [ + "fax", + "flate2", + "half", + "quick-error 2.0.1", + "weezl", + "zune-jpeg 0.4.21", +] + +[[package]] +name = "time" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134" +dependencies = [ + "deranged", + "libc", + "num-conv", + "num_threads", + "powerfmt", + "serde_core", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109" + +[[package]] +name = "time-macros" +version = "0.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85" +dependencies = [ + "num-conv", + "time-core", +] + +[[package]] +name = "tiny-skia" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab" +dependencies = [ + "arrayref", + "arrayvec", + "bytemuck", + "cfg-if", + "log", + "tiny-skia-path", +] + +[[package]] +name = "tiny-skia-path" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93" +dependencies = [ + "arrayref", + "bytemuck", + "strict-num", +] + +[[package]] +name = "tinystr" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643" +dependencies = [ + "displaydoc", + "serde_core", + "zerovec", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "tinyvec" +version = "1.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee" + +[[package]] +name = "tokio" +version = "1.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed" +dependencies = [ + "pin-project-lite", +] + +[[package]] +name = "toml" +version = "1.1.6+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "920602543f0911ab71da12c50d59701da54c196d1a2bf5cb4b75667f137a406a" +dependencies = [ + "indexmap", + "serde_core", + "serde_spanned", + "toml_datetime", + "toml_parser", + "toml_writer", + "winnow 1.0.4", +] + +[[package]] +name = "toml_datetime" +version = "1.1.1+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_edit" +version = "0.25.15+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1340ea94a5856333492c9064b02c778b191dd2c853778d9609debdcdfea3a614" +dependencies = [ + "indexmap", + "toml_datetime", + "toml_parser", + "winnow 1.0.4", +] + +[[package]] +name = "toml_parser" +version = "1.1.3+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56" +dependencies = [ + "winnow 1.0.4", +] + +[[package]] +name = "toml_writer" +version = "1.1.2+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d56353a2a665ad0f41a421187180aab746c8c325620617ad883a99a1cbe66d2" + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "tracing-chrome" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf0a738ed5d6450a9fb96e86a23ad808de2b727fd1394585da5cdd6788ffe724" +dependencies = [ + "serde_json", + "tracing-core", + "tracing-subscriber", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-error" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b1581020d7a273442f5b45074a6a57d5757ad0a47dac0e9f0bd57b81936f3db" +dependencies = [ + "tracing", + "tracing-subscriber", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-oslog" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d76902d2a8d5f9f55a81155c08971734071968c90f2d9bfe645fe700579b2950" +dependencies = [ + "cc", + "cfg-if", + "tracing-core", + "tracing-subscriber", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex-automata", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "tracing-tracy" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b326790213b869d948a5d1ea56472ed5b20c7cefde07684ee35d6b7a980fef1" +dependencies = [ + "tracing-core", + "tracing-subscriber", + "tracy-client", +] + +[[package]] +name = "tracing-wasm" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07" +dependencies = [ + "tracing", + "tracing-subscriber", + "wasm-bindgen", +] + +[[package]] +name = "tracy-client" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d93fd676d8946eaeaff4881d26d2240a8d106fcaccbd47cb9f1389e3561ba490" +dependencies = [ + "loom", + "once_cell", + "tracy-client-sys", +] + +[[package]] +name = "tracy-client-sys" +version = "0.30.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eef8a023d2b19f44e430da334f7dfb5e5db219bb83e2b4f56a09c1cb12abe915" +dependencies = [ + "cc", + "windows-targets 0.53.5", +] + +[[package]] +name = "tree_magic_mini" +version = "3.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6" +dependencies = [ + "memchr", + "nom 8.0.0", + "petgraph", +] + +[[package]] +name = "try-lock" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" + +[[package]] +name = "ttf-parser" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31" + +[[package]] +name = "tungstenite" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442" +dependencies = [ + "bytes", + "data-encoding", + "http", + "httparse", + "log", + "rand 0.9.5", + "sha1", + "thiserror 2.0.21", + "utf-8", +] + +[[package]] +name = "twox-hash" +version = "2.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5283634e518fe9e82c7b20520bb4bc209009fd16c82077c802f8111ecbb0117a" + +[[package]] +name = "typeid" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c" + +[[package]] +name = "typenum" +version = "1.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" + +[[package]] +name = "typewit" +version = "1.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "214ca0b2191785cbc06209b9ca1861e048e39b5ba33574b3cedd58363d5bb5f6" + +[[package]] +name = "ucd-trie" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971" + +[[package]] +name = "uds_windows" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e" +dependencies = [ + "memoffset", + "tempfile", + "windows-sys 0.61.2", +] + +[[package]] +name = "ui_test" +version = "0.30.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ada249620d81f010b9a1472b63a5077ac7c722dd0f4bacf6528b313d0b8c15d8" +dependencies = [ + "annotate-snippets 0.11.5", + "anyhow", + "bstr", + "cargo-platform", + "cargo_metadata", + "color-eyre", + "colored", + "comma", + "crossbeam-channel", + "indicatif", + "levenshtein", + "prettydiff", + "regex", + "rustc_version", + "rustfix", + "serde", + "serde_json", + "spanned", +] + +[[package]] +name = "unarray" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "unicode-linebreak" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f" + +[[package]] +name = "unicode-segmentation" +version = "1.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8" + +[[package]] +name = "unicode-truncate" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16b380a1238663e5f8a691f9039c73e1cdae598a30e9855f541d29b08b53e9a5" +dependencies = [ + "itertools 0.14.0", + "unicode-segmentation", + "unicode-width 0.2.2", +] + +[[package]] +name = "unicode-width" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af" + +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "unit-prefix" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3" + +[[package]] +name = "unsynn" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "501a7adf1a4bd9951501e5c66621e972ef8874d787628b7f90e64f936ef7ec0a" +dependencies = [ + "mutants", + "proc-macro2", + "rustc-hash 2.1.3", +] + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "ureq" +version = "3.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7ac20be9b7726e0bbdbf974c059676d9acb1cd414961f570a4e8231cacd7fc" +dependencies = [ + "base64 0.23.1", + "cookie_store", + "flate2", + "log", + "percent-encoding", + "rustls", + "rustls-pki-types", + "rustls-platform-verifier", + "serde", + "serde_json", + "ureq-proto", + "utf8-zero", + "webpki-roots", +] + +[[package]] +name = "ureq-proto" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f86fd172ccca569e458f61b6bdd6220965a9ef36e672a6852953b51a0e1583be" +dependencies = [ + "base64 0.23.1", + "http", + "httparse", + "log", +] + +[[package]] +name = "url" +version = "2.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", + "serde", +] + +[[package]] +name = "urlencoding" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da" + +[[package]] +name = "utf-8" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" + +[[package]] +name = "utf8-zero" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8c0a043c9540bae7c578c88f91dda8bd82e59ae27c21baca69c8b191aaf5a6e" + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "uuid" +version = "1.26.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ef6dac1e96601b4fb3acccccff2139741fcb757cb9a36089bf5be91cfb285ce" +dependencies = [ + "atomic", + "getrandom 0.4.3", + "js-sys", + "serde_core", + "wasm-bindgen", +] + +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + +[[package]] +name = "variadics_please" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b53d0f7f2d0182759a549f1f313ce16b07d8f9ba93098157b5fa10ee3e61117f" +dependencies = [ + "quote", + "unsynn", +] + +[[package]] +name = "vec_map" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191" + +[[package]] +name = "version-compare" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "vtparse" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d9b2acfb050df409c972a37d3b8e08cdea3bddb0c09db9d53137e504cfabed0" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "wait-timeout" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11" +dependencies = [ + "libc", +] + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "want" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" +dependencies = [ + "try-lock", +] + +[[package]] +name = "warnings" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64f68998838dab65727c9b30465595c6f7c953313559371ca8bf31759b3680ad" +dependencies = [ + "pin-project", + "tracing", + "warnings-macro", +] + +[[package]] +name = "warnings-macro" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59195a1db0e95b920366d949ba5e0d3fc0e70b67c09be15ce5abb790106b0571" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasip2" +version = "1.0.1+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.79" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3cbab34de2d982e9b48e18d216d04c4a6f641066ff19ffb699980f591ee3610e" +dependencies = [ + "js-sys", + "tokio", + "wasm-bindgen", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 3.0.6", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wayland-backend" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38a91b4eaddff87b1cd1074985e3713da4af2c49742d1b356b2c01670a67a078" +dependencies = [ + "cc", + "downcast-rs 1.2.1", + "rustix 1.1.5", + "scoped-tls", + "smallvec", + "wayland-sys", +] + +[[package]] +name = "wayland-client" +version = "0.31.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3c36a0f861ad76d0901f2800b46321410d9f73f2ea88aac0650d86c32688073" +dependencies = [ + "bitflags 2.13.2", + "rustix 1.1.5", + "wayland-backend", + "wayland-scanner", +] + +[[package]] +name = "wayland-csd-frame" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e" +dependencies = [ + "bitflags 2.13.2", + "cursor-icon", + "wayland-backend", +] + +[[package]] +name = "wayland-cursor" +version = "0.31.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a52d18780be9b1314328a3de5f930b73d2200112e3849ca6cb11822793fb34d" +dependencies = [ + "rustix 1.1.5", + "wayland-client", + "xcursor", +] + +[[package]] +name = "wayland-protocols" +version = "0.32.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "563a85523cade2429938e790815fd7319062103b9f4a2dc806e9b53b95982d8f" +dependencies = [ + "bitflags 2.13.2", + "wayland-backend", + "wayland-client", + "wayland-scanner", +] + +[[package]] +name = "wayland-protocols-plasma" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b6d8cf1eb2c1c31ed1f5643c88a6e53538129d4af80030c8cabd1f9fa884d91" +dependencies = [ + "bitflags 2.13.2", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-scanner", +] + +[[package]] +name = "wayland-protocols-wlr" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234" +dependencies = [ + "bitflags 2.13.2", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-scanner", +] + +[[package]] +name = "wayland-scanner" +version = "0.31.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "338e30461b3a2b67d70eb30a6d89f8e0c93a833e07d2ae89085cd070c4a00ac0" +dependencies = [ + "proc-macro2", + "quick-xml 0.41.0", + "quote", +] + +[[package]] +name = "wayland-sys" +version = "0.31.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be" +dependencies = [ + "dlib", + "log", + "once_cell", + "pkg-config", +] + +[[package]] +name = "weak-table" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5eba2ec791141b0bf4db542f6b038a8f9310cee33e076cb181245780b09a24ff" +dependencies = [ + "cfg-if", + "hashbrown 0.16.1", +] + +[[package]] +name = "web-sys" +version = "0.3.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88261b9deccee56594c11a3460c462c41f58d148598fe70ad77070126a68aba4" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-task" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1cdc136a53ccd64a1211f107ccc34404769fbcc0f165f1afa065f5d88ab93538" +dependencies = [ + "async-task", + "cfg-if", + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webpki-root-certs" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "webpki-roots" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "weezl" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88" + +[[package]] +name = "wesl" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fb1ecb13a378c984af75ed271558f9295c05579554b97d72d9fa0c474af7f8e" +dependencies = [ + "annotate-snippets 0.12.16", + "anstream", + "derive_more", + "half", + "itertools 0.15.0", + "num-traits", + "thiserror 2.0.21", + "wesl-macros", + "wgsl-parse", + "wgsl-types", +] + +[[package]] +name = "wesl-macros" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8013e38716b704587f72fe8a077528503d18af7240e6a19f6792baff6e16f8d" +dependencies = [ + "itertools 0.15.0", + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "wezterm-bidi" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c0a6e355560527dd2d1cf7890652f4f09bb3433b6aadade4c9b5ed76de5f3ec" +dependencies = [ + "log", + "wezterm-dynamic", +] + +[[package]] +name = "wezterm-blob-leases" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "692daff6d93d94e29e4114544ef6d5c942a7ed998b37abdc19b17136ea428eb7" +dependencies = [ + "getrandom 0.3.4", + "mac_address", + "sha2", + "thiserror 1.0.69", + "uuid", +] + +[[package]] +name = "wezterm-color-types" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7de81ef35c9010270d63772bebef2f2d6d1f2d20a983d27505ac850b8c4b4296" +dependencies = [ + "csscolorparser", + "deltae", + "lazy_static", + "wezterm-dynamic", +] + +[[package]] +name = "wezterm-dynamic" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f2ab60e120fd6eaa68d9567f3226e876684639d22a4219b313ff69ec0ccd5ac" +dependencies = [ + "log", + "ordered-float 4.6.0", + "strsim", + "thiserror 1.0.69", + "wezterm-dynamic-derive", +] + +[[package]] +name = "wezterm-dynamic-derive" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46c0cf2d539c645b448eaffec9ec494b8b19bd5077d9e58cb1ae7efece8d575b" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "wezterm-input-types" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7012add459f951456ec9d6c7e6fc340b1ce15d6fc9629f8c42853412c029e57e" +dependencies = [ + "bitflags 1.3.2", + "euclid", + "lazy_static", + "serde", + "wezterm-dynamic", +] + +[[package]] +name = "wgpu" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "527ccdf43dd5b2e8676eed9984ce00e2bbb0a1b85b70c1969dcb6cd2eb55ab9e" +dependencies = [ + "arrayvec", + "bitflags 2.13.2", + "bytemuck", + "cfg-if", + "cfg_aliases", + "document-features", + "hashbrown 0.17.1", + "js-sys", + "log", + "naga", + "portable-atomic", + "profiling", + "raw-window-handle", + "smallvec", + "static_assertions", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "wgpu-core", + "wgpu-hal", + "wgpu-types", +] + +[[package]] +name = "wgpu-core" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14c018fce9b6270aa203c2fdd56f3cce996713534bd757e4ea58c8560b121f14" +dependencies = [ + "arrayvec", + "bit-set 0.10.0", + "bit-vec 0.9.1", + "bitflags 2.13.2", + "bytemuck", + "cfg_aliases", + "document-features", + "hashbrown 0.17.1", + "indexmap", + "log", + "naga", + "naga-types", + "once_cell", + "parking_lot", + "portable-atomic", + "profiling", + "raw-window-handle", + "rustc-hash 1.1.0", + "smallvec", + "thiserror 2.0.21", + "wgpu-core-deps-apple", + "wgpu-core-deps-emscripten", + "wgpu-core-deps-wasm", + "wgpu-core-deps-windows-linux-android", + "wgpu-hal", + "wgpu-naga-bridge", + "wgpu-types", +] + +[[package]] +name = "wgpu-core-deps-apple" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "061f3d319a40d39d00b1ecc2c33b89fe21d4e6fe01859df3500a3a8ecccd6b68" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-core-deps-emscripten" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d98b86cf4abf524a902dd35f18ca6a3f08fc2ae9847c8f10b48e30491b1f0b86" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-core-deps-wasm" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d260ca2ca8adc654f513a869bf3cac0b47f5b8d3f87803d6942015f8de597aae" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-core-deps-windows-linux-android" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7586165fd5f6d881cb9ce4bb71f40d6caab2c0f1837e3fc1d9788a197fb6004f" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-hal" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6b7fb58561a792bc237628ba0792e332de418fefe145f13b5ed8201e6d52f58" +dependencies = [ + "android_system_properties", + "arrayvec", + "ash", + "bit-set 0.10.0", + "bitflags 2.13.2", + "block2 0.6.2", + "bytemuck", + "cfg-if", + "cfg_aliases", + "glow", + "glutin_wgl_sys", + "gpu-allocator", + "hashbrown 0.17.1", + "js-sys", + "khronos-egl", + "libc", + "libloading", + "log", + "mach-dxcompiler-rs", + "naga", + "naga-types", + "ndk-sys", + "objc2 0.6.4", + "objc2-core-foundation", + "objc2-core-graphics", + "objc2-foundation 0.3.2", + "objc2-metal 0.3.2", + "objc2-quartz-core 0.3.2", + "once_cell", + "ordered-float 5.4.0", + "parking_lot", + "portable-atomic", + "portable-atomic-util", + "profiling", + "range-alloc", + "raw-window-handle", + "raw-window-metal", + "renderdoc-sys", + "smallvec", + "static_assertions", + "thiserror 2.0.21", + "wasm-bindgen", + "wayland-sys", + "web-sys", + "wgpu-naga-bridge", + "wgpu-types", + "windows", + "windows-core", + "windows-result", +] + +[[package]] +name = "wgpu-naga-bridge" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2f62e73117bb7a62bfd9c5a5841438a823f6566c6442a808ee269d2d055c081" +dependencies = [ + "naga", + "wgpu-types", +] + +[[package]] +name = "wgpu-types" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99dad6f1fbdbbdb4c278a6508b059d44688f5cebddf78d005a46a31340269286" +dependencies = [ + "bitflags 2.13.2", + "bytemuck", + "js-sys", + "log", + "naga-types", + "raw-window-handle", + "serde", + "static_assertions", + "web-sys", +] + +[[package]] +name = "wgsl-parse" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37836b24c0b4854f9a6f820585ccd5e02ad917070fe8aa67b697bf96c286ce63" +dependencies = [ + "annotate-snippets 0.12.16", + "derive_more", + "itertools 0.15.0", + "lalrpop", + "lalrpop-util", + "lexical", + "logos", + "thiserror 2.0.21", + "wgsl-types", +] + +[[package]] +name = "wgsl-types" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8286b1a2ce08736a048da13f6fcdd427c7baf7e3c48e0b5a0c51f954675b2f73" +dependencies = [ + "half", + "itertools 0.15.0", + "num-traits", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" +dependencies = [ + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", +] + +[[package]] +name = "windows-collections" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" +dependencies = [ + "windows-core", +] + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-future" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" +dependencies = [ + "windows-core", + "windows-link", + "windows-threading", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-numerics" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" +dependencies = [ + "windows-core", + "windows-link", +] + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" +dependencies = [ + "windows-targets 0.42.2", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.5", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" +dependencies = [ + "windows_aarch64_gnullvm 0.42.2", + "windows_aarch64_msvc 0.42.2", + "windows_i686_gnu 0.42.2", + "windows_i686_msvc 0.42.2", + "windows_x86_64_gnu 0.42.2", + "windows_x86_64_gnullvm 0.42.2", + "windows_x86_64_msvc 0.42.2", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm 0.52.6", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.53.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + +[[package]] +name = "windows-threading" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + +[[package]] +name = "windows_i686_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + +[[package]] +name = "windows_i686_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" + +[[package]] +name = "winit" +version = "0.30.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6755fa58a9f8350bd1e472d4c3fcc25f824ec358933bba33306d0b63df5978d" +dependencies = [ + "ahash", + "android-activity", + "atomic-waker", + "bitflags 2.13.2", + "block2 0.5.1", + "bytemuck", + "calloop", + "cfg_aliases", + "concurrent-queue", + "core-foundation 0.9.4", + "core-graphics", + "cursor-icon", + "dpi", + "js-sys", + "libc", + "memmap2", + "ndk", + "objc2 0.5.2", + "objc2-app-kit 0.2.2", + "objc2-foundation 0.2.2", + "objc2-ui-kit", + "orbclient", + "percent-encoding", + "pin-project", + "raw-window-handle", + "redox_syscall 0.4.1", + "rustix 0.38.44", + "sctk-adwaita", + "smithay-client-toolkit", + "smol_str", + "tracing", + "unicode-segmentation", + "wasm-bindgen", + "wasm-bindgen-futures", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-protocols-plasma", + "web-sys", + "web-time", + "windows-sys 0.52.0", + "x11-dl", + "x11rb", + "xkbcommon-dl", +] + +[[package]] +name = "winnow" +version = "0.7.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945" +dependencies = [ + "memchr", +] + +[[package]] +name = "winnow" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81" +dependencies = [ + "memchr", +] + +[[package]] +name = "wit-bindgen" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" + +[[package]] +name = "wl-clipboard-rs" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d7888ccd4896447b2d14d3a9350a85df2aeb6f181e2e7a31349d104ac46cac1" +dependencies = [ + "libc", + "log", + "os_pipe", + "rustix 1.1.5", + "thiserror 2.0.21", + "tree_magic_mini", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-protocols-wlr", +] + +[[package]] +name = "writeable" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc" + +[[package]] +name = "wyz" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" +dependencies = [ + "tap", +] + +[[package]] +name = "x11-dl" +version = "2.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f" +dependencies = [ + "libc", + "once_cell", + "pkg-config", +] + +[[package]] +name = "x11rb" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414" +dependencies = [ + "as-raw-xcb-connection", + "gethostname", + "libc", + "libloading", + "once_cell", + "rustix 1.1.5", + "x11rb-protocol", +] + +[[package]] +name = "x11rb-protocol" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd" + +[[package]] +name = "x264" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc93ffd258cebeced05f02b73fb291e17fe78a6a99bfcff1091e6606ed0dec92" +dependencies = [ + "pkg-config", + "x264-sys", +] + +[[package]] +name = "x264-sys" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b694bc460acd21d48a05977f57025a93e2a4d4a10feffde9f0c66925d6e72ff4" +dependencies = [ + "bindgen 0.72.1", + "system-deps", +] + +[[package]] +name = "xcursor" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "163b33ed8786455e2fa5d72f554057ce3f3182425434f756cd39c99839d88e23" + +[[package]] +name = "xkbcommon-dl" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5" +dependencies = [ + "bitflags 2.13.2", + "dlib", + "log", + "once_cell", + "xkeysym", +] + +[[package]] +name = "xkeysym" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56" + +[[package]] +name = "xml-rs" +version = "0.8.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7" + +[[package]] +name = "xshell" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e7290c623014758632efe00737145b6867b66292c42167f2ec381eb566a373d" +dependencies = [ + "xshell-macros", +] + +[[package]] +name = "xshell-macros" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547" + +[[package]] +name = "yazi" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e01738255b5a16e78bbb83e7fbba0a1e7dd506905cfc53f4622d89015a03fbb5" + +[[package]] +name = "yeslogic-fontconfig-sys" +version = "6.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d8b8abf912b9a29ff112e1671c97c33636903d13a69712037190e6805af4f76" +dependencies = [ + "dlib", + "once_cell", + "pkg-config", +] + +[[package]] +name = "yoke" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5" +dependencies = [ + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33811428bee40dbceb6d545e95754741d17a6aef9a4849f0fd62e2ba4f412a78" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", + "synstructure", +] + +[[package]] +name = "zbus" +version = "5.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bfeff997a0aaa3eb20c4652baf788d2dfa6d2839a0ead0b3ff69ce2f9c4bdd1" +dependencies = [ + "async-broadcast", + "async-executor", + "async-io", + "async-lock", + "async-process", + "async-recursion", + "async-task", + "async-trait", + "blocking", + "enumflags2", + "event-listener", + "futures-core", + "futures-lite", + "hex", + "libc", + "ordered-stream", + "rustix 1.1.5", + "serde", + "serde_repr", + "tracing", + "uds_windows", + "uuid", + "windows-sys 0.61.2", + "winnow 0.7.15", + "zbus_macros", + "zbus_names", + "zvariant", +] + +[[package]] +name = "zbus-lockstep" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6998de05217a084b7578728a9443d04ea4cd80f2a0839b8d78770b76ccd45863" +dependencies = [ + "zbus_xml", + "zvariant", +] + +[[package]] +name = "zbus-lockstep-macros" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10da05367f3a7b7553c8cdf8fa91aee6b64afebe32b51c95177957efc47ca3a0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", + "zbus-lockstep", + "zbus_xml", + "zvariant", +] + +[[package]] +name = "zbus_macros" +version = "5.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bbd5a90dbe8feee5b13def448427ae314ccd26a49cac47905cafefb9ff846f1" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 2.0.119", + "zbus_names", + "zvariant", + "zvariant_utils", +] + +[[package]] +name = "zbus_names" +version = "4.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ffd8af6d5b78619bab301ff3c560a5bd22426150253db278f164d6cf3b72c50f" +dependencies = [ + "serde", + "winnow 0.7.15", + "zvariant", +] + +[[package]] +name = "zbus_xml" +version = "5.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "441a0064125265655bccc3a6af6bef56814d9277ac83fce48b1cd7e160b80eac" +dependencies = [ + "quick-xml 0.38.4", + "serde", + "zbus_names", + "zvariant", +] + +[[package]] +name = "zeno" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df3dc4292935e51816d896edcd52aa30bc297907c26167fec31e2b0c6a32524" + +[[package]] +name = "zero_day" +version = "0.1.0" +dependencies = [ + "argh", + "bevy", +] + +[[package]] +name = "zerocopy" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zerofrom" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", + "synstructure", +] + +[[package]] +name = "zeroize" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e" + +[[package]] +name = "zerotrie" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "zerovec" +version = "0.11.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8" +dependencies = [ + "serde", + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "zlib-rs" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64d80649ab6db9d9f6f9c80a40becd948eda4714a0a5ac8c4d157a32231c7882" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.1.0+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ef0a8027ec3ee71300ab3bcbcd0393f434aa72b91ca6d635a39941deae8eea0" +dependencies = [ + "cc", + "pkg-config", +] + +[[package]] +name = "zune-core" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a" + +[[package]] +name = "zune-core" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b" + +[[package]] +name = "zune-inflate" +version = "0.2.54" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "zune-jpeg" +version = "0.4.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29ce2c8a9384ad323cf564b67da86e21d3cfdff87908bc1223ed5c99bc792713" +dependencies = [ + "zune-core 0.4.12", +] + +[[package]] +name = "zune-jpeg" +version = "0.5.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296" +dependencies = [ + "zune-core 0.5.3", +] + +[[package]] +name = "zvariant" +version = "5.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68b64ef4f40c7951337ddc7023dd03528a57a3ce3408ee9da5e948bd29b232c4" +dependencies = [ + "endi", + "enumflags2", + "serde", + "winnow 0.7.15", + "zvariant_derive", + "zvariant_utils", +] + +[[package]] +name = "zvariant_derive" +version = "5.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "484d5d975eb7afb52cc6b929c13d3719a20ad650fea4120e6310de3fc55e415c" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 2.0.119", + "zvariant_utils", +] + +[[package]] +name = "zvariant_utils" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f75c23a64ef8f40f13a6989991e643554d9bef1d682a281160cf0c1bc389c5e9" +dependencies = [ + "proc-macro2", + "quote", + "serde", + "syn 2.0.119", + "winnow 0.7.15", +] diff --git a/scripts/bench-incremental.sh b/scripts/bench-incremental.sh new file mode 100755 index 0000000..41cc19b --- /dev/null +++ b/scripts/bench-incremental.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +# Incremental `cargo check` after an edit, headstart off and on: the dev +# loop. Each run appends a unique marker to a function body in (so +# the crate and everything depending on it re-checks), then times +# `cargo check` in a warm target dir per mode. +# +# scripts/bench-incremental.sh [-n runs] +# +# e.g. scripts/bench-incremental.sh cargo crates/cargo-util/src/paths.rs "pub fn normalize_path" +set -uo pipefail +root="$(cd "$(dirname "$0")/.." && pwd)" +runs=5 +while getopts n: opt; do + case $opt in n) runs=$OPTARG ;; *) exit 2 ;; esac +done +shift $((OPTIND - 1)) +[ $# -eq 3 ] || { echo "usage: $0 [-n runs] " >&2; exit 2; } +dir=$(cd "$1" && pwd) file=$2 fn=$3 +export RUSTC=$root/rustc/build/host/stage1/bin/rustc RUSTC_WRAPPER= CARGO_INCREMENTAL=1 +cargo=$root/cargo/target/release/cargo +now() { perl -MTime::HiRes=time -e 'printf "%.3f", time'; } +cp "$dir/$file" "$dir/$file.orig" +trap 'mv "$dir/$file.orig" "$dir/$file"' EXIT +check() { # + (cd "$dir" && CARGO_TARGET_DIR="$dir/target-hs$1" CARGO_HEADSTART=$1 "$cargo" check -q --offline >/dev/null 2>&1) +} +check 0; check 1 # warm both target dirs +for run in $(seq "$runs"); do + # A body-only edit: a new statement at the start of the function. + before=$(cksum < "$dir/$file") + FN=$fn RUN=$run perl -0pi -e 's/(\Q$ENV{FN}\E[^{]*\{)/$1 let _headstart_edit = $ENV{RUN};/' "$dir/$file" + [ "$(cksum < "$dir/$file")" != "$before" ] || { echo "no function starting with '$fn' in $file" >&2; exit 1; } + for mode in 0 1; do + start=$(now); check $mode; status=$? + printf '%s\t%s\t%s\t%.2f\t%s\n' "$(basename "$dir"):$file" "$([ $mode = 1 ] && echo on || echo off)" "$run" "$(perl -e "print $(now) - $start")" "$status" + done +done diff --git a/scripts/bench-mem.sh b/scripts/bench-mem.sh new file mode 100755 index 0000000..77580d9 --- /dev/null +++ b/scripts/bench-mem.sh @@ -0,0 +1,38 @@ +#!/usr/bin/env bash +# Peak memory of clean `cargo check` builds, headstart off and on: samples +# the total resident memory of all rustc processes every 100 ms. +# +# scripts/bench-mem.sh [-n runs] [-o out.tsv] ... +# +# Projects are built in place (their target dir is deleted first). Extra +# rustc flags can be passed with RUSTFLAGS. +set -uo pipefail +root="$(cd "$(dirname "$0")/.." && pwd)" +runs=3 out=/dev/stdout +while getopts n:o: opt; do + case $opt in n) runs=$OPTARG ;; o) out=$OPTARG ;; *) exit 2 ;; esac +done +shift $((OPTIND - 1)) +export RUSTC=$root/rustc/build/host/stage1/bin/rustc RUSTC_WRAPPER= +cargo=$root/cargo/target/release/cargo +now() { perl -MTime::HiRes=time -e 'printf "%.3f", time'; } +rss_mb() { ps -A -o rss=,comm= | awk '$2 ~ /rustc$/ {s += $1} END {printf "%d", s / 1024}'; } +printf 'project\tmode\trun\tseconds\tpeak_rss_mb\n' > "$out" +for dir in "$@"; do + name=$(basename "$dir") + for run in $(seq "$runs"); do + for mode in off on; do + rm -rf "$dir/target" + start=$(now) + (cd "$dir" && CARGO_HEADSTART=$([ $mode = on ] && echo 1 || echo 0) \ + "$cargo" check -q --offline >/dev/null 2>&1) & + pid=$! peak=0 + while kill -0 $pid 2>/dev/null; do + mb=$(rss_mb); [ "$mb" -gt "$peak" ] && peak=$mb + sleep 0.1 + done + wait $pid + printf '%s\t%s\t%s\t%.2f\t%s\n' "$name" "$mode" "$run" "$(perl -e "print $(now) - $start")" "$peak" >> "$out" + done + done +done diff --git a/scripts/bench.sh b/scripts/bench.sh new file mode 100755 index 0000000..54601a8 --- /dev/null +++ b/scripts/bench.sh @@ -0,0 +1,85 @@ +#!/usr/bin/env bash +# Time clean `cargo check` (or `cargo build`, with `-c build`) builds with and +# without headstart, alternating, with the same patched rustc and cargo +# (headstart off = upstream behavior): +# +# scripts/bench.sh [-n runs] [-j jobs] [-c check|build] [-o out-dir] [::cargo args]... +# +# For example, `vaultwarden::--features sqlite`. +# +# Each project is copied to /work first. Writes /runs.tsv +# (project, mode, run, seconds, exit status) and, for each build, the +# per-rustc schedule and the diagnostics under /schedules/. Prints +# a table of medians, and any project whose diagnostics differ between +# modes. +set -uo pipefail +root="$(cd "$(dirname "$0")/.." && pwd)" +runs=5 jobs=$(sysctl -n hw.ncpu 2>/dev/null || nproc) out= command=check +while getopts n:j:o:c: opt; do + case $opt in + n) runs=$OPTARG ;; j) jobs=$OPTARG ;; o) out=$OPTARG ;; c) command=$OPTARG ;; + *) exit 2 ;; + esac +done +shift $((OPTIND - 1)) +# A new directory per run by default: an existing runs.tsv is appended to, +# and its medians cover every row. +out=${out:-$root/results/$(date +%F-%H%M%S)-$command} +[ $# -gt 0 ] || { echo "usage: $0 [-n runs] [-j jobs] [-c check|build] [-o out-dir] [::cargo args]..." >&2; exit 2; } + +export RUSTC=$root/rustc/build/host/stage1/bin/rustc +export RUSTC_WRAPPER=$root/scripts/log-rustc +cargo=$root/cargo/target/release/cargo +now() { perl -MTime::HiRes=time -e 'printf "%.3f", time'; } + +mkdir -p "$out/work" "$out/schedules" +out=$(cd "$out" && pwd) +[ -f "$out/runs.tsv" ] || printf 'project\tmode\trun\tseconds\tstatus\n' > "$out/runs.tsv" +for spec in "$@"; do + src=${spec%%::*} args= + [ "$src" = "$spec" ] || args=${spec#*::} + name=$(basename "$src") + rsync -a --delete --exclude target "$src/" "$out/work/$name/" + (cd "$out/work/$name" && "$cargo" fetch -q) || { echo "$name: fetch failed" >&2; continue; } + for run in $(seq "$runs"); do + for mode in off on; do + rm -rf "$out/work/$name/target" + log=$out/schedules/$name.$mode.$run.txt + rm -f "$log" + start=$(now) + (cd "$out/work/$name" && + HEADSTART_LOG=$log CARGO_HEADSTART=$([ $mode = on ] && echo 1 || echo 0) \ + "$cargo" "$command" -q -j "$jobs" --offline --message-format=short $args >/dev/null 2>"${log%.txt}.err") + status=$? + secs=$(perl -e "printf '%.2f', $(now) - $start") + printf '%s\t%s\t%s\t%s\t%s\n' "$name" "$mode" "$run" "$secs" "$status" >> "$out/runs.tsv" + echo "$name $mode #$run: ${secs}s (exit $status)" + done + done + rm -rf "$out/work/$name/target" +done + +python3 - "$out/runs.tsv" <<'PY' +import csv, os, statistics, sys +rows = list(csv.DictReader(open(sys.argv[1]), delimiter="\t")) +sched = os.path.join(os.path.dirname(sys.argv[1]), "schedules") +def diagnostics(p, mode, run): + try: + return sorted(open(os.path.join(sched, f"{p}.{mode}.{run}.err")).read().splitlines()) + except FileNotFoundError: + return None +differ = sorted({r["project"] for r in rows if r["mode"] == "on" + and diagnostics(r["project"], "on", r["run"]) != diagnostics(r["project"], "off", r["run"])}) +times = {} +for r in rows: + if r["status"] == "0": + times.setdefault(r["project"], {}).setdefault(r["mode"], []).append(float(r["seconds"])) +print("\n| project | today (median) | headstart (median) | saved | runs |") +print("|---|--:|--:|--:|--:|") +for p, m in times.items(): + if "off" in m and "on" in m: + off, on = statistics.median(m["off"]), statistics.median(m["on"]) + print(f"| {p} | {off:.2f} s | {on:.2f} s | {100 * (1 - on / off):.0f}% | {len(m['on'])} |") +if differ: + print("\ndiagnostics differ between modes:", ", ".join(differ)) +PY diff --git a/scripts/check-errors.sh b/scripts/check-errors.sh new file mode 100755 index 0000000..df5fc69 --- /dev/null +++ b/scripts/check-errors.sh @@ -0,0 +1,47 @@ +#!/usr/bin/env bash +# Checks that headstart doesn't change what a build reports: for each +# scenario in tests/errors (clean, an error in a dependency's body, an error +# in the binary), `cargo check` and `cargo build` must print the same +# diagnostics, the same JSON messages and exit the same with headstart off +# and on, and a built binary must print the same. Output that already +# depends on timing is ignored: progress lines (`Checking`, `Compiling`, +# `Finished`), "waiting for other jobs", lock waits (`Blocking`), and the +# order of JSON messages across crates. +set -uo pipefail +root="$(cd "$(dirname "$0")/.." && pwd)" +export RUSTC=$root/rustc/build/host/stage1/bin/rustc RUSTC_WRAPPER= +cargo=$root/cargo/target/release/cargo +tmp=$(mktemp -d) +cd "$root/tests/errors" +status=0 +for command in check build; do +for scenario in "" "--features slow/broken" "--features app/broken"; do + for mode in 0 1; do + for format in human json; do + rm -rf target + CARGO_HEADSTART=$mode "$cargo" $command --color never --message-format "$format" $scenario \ + >"$tmp/$format.$mode.out" 2>"$tmp/$format.$mode.err" + echo "exit $?" >>"$tmp/$format.$mode.out" + if [ -x target/debug/app ]; then target/debug/app >>"$tmp/$format.$mode.out" 2>&1; fi + # Cargo doesn't order JSON messages across crates (it varies with -j), + # and headstart holds a crate's messages until its dependencies finish. + if [ $format = json ]; then sort -o "$tmp/$format.$mode.out" "$tmp/$format.$mode.out"; fi + grep -v -e '^ *Checking ' -e '^ *Compiling ' -e '^ *Finished ' -e '^ *Blocking ' -e 'build failed, waiting for other jobs' "$tmp/$format.$mode.err" \ + >"$tmp/$format.$mode.err.filtered" + done + done + for format in human json; do + if diff -q "$tmp/$format.0.out" "$tmp/$format.1.out" >/dev/null && + diff -q "$tmp/$format.0.err.filtered" "$tmp/$format.1.err.filtered" >/dev/null; then + echo "same $command ${scenario:-clean} ($format)" + else + echo "DIFFER $command ${scenario:-clean} ($format)" + diff "$tmp/$format.0.err.filtered" "$tmp/$format.1.err.filtered" + diff "$tmp/$format.0.out" "$tmp/$format.1.out" + status=1 + fi + done +done +done +rm -rf "$tmp" +exit $status diff --git a/scripts/check-incremental.sh b/scripts/check-incremental.sh new file mode 100755 index 0000000..3e3c4bb --- /dev/null +++ b/scripts/check-incremental.sh @@ -0,0 +1,61 @@ +#!/usr/bin/env bash +# Checks headstart under incremental compilation: runs one sequence of +# edits to a copy of tests/errors twice, with headstart off and on, each in +# its own directory, and compares the output after every step. Finally +# compares both against a clean build of the last state. +# +# scripts/check-incremental.sh [check|build] +# +# With `build`, each step also runs the built binary. +set -uo pipefail +command=${1:-check} +root="$(cd "$(dirname "$0")/.." && pwd)" +export RUSTC=$root/rustc/build/host/stage1/bin/rustc RUSTC_WRAPPER= CARGO_INCREMENTAL=1 +cargo=$root/cargo/target/release/cargo +tmp=$(mktemp -d) +for mode in 0 1; do + cp -R "$root/tests/errors" "$tmp/ws$mode" + rm -rf "$tmp/ws$mode/target" +done + +step() { # + local name=$1 edit=$2 mode out + for mode in 0 1; do + (cd "$tmp/ws$mode" && eval "$edit" && sleep 1 && + CARGO_HEADSTART=$mode "$cargo" $command --color never --message-format short 2>&1 | + grep -v -e '^ *Checking ' -e '^ *Compiling ' -e '^ *Finished ' -e '^ *Blocking ' -e 'build failed, waiting for other jobs' > "$tmp/$name.$mode" + echo "exit ${PIPESTATUS[0]}" >> "$tmp/$name.$mode" + if [ $command = build ] && [ -x target/debug/app ]; then target/debug/app >> "$tmp/$name.$mode" 2>&1; fi) + done + if diff -q "$tmp/$name.0" "$tmp/$name.1" >/dev/null && ! grep -q "panicked\|internal compiler error" "$tmp/$name.1"; then + echo "same $name ($(tail -1 "$tmp/$name.1"))" + else + echo "DIFFER $name"; diff "$tmp/$name.0" "$tmp/$name.1"; status=1 + fi +} +status=0 +step initial ":" +step body-edit "sed -i.bak 's/wrapping_mul(3)/wrapping_mul(4)/' slow/src/lib.rs" +step add-opaque "printf 'pub fn adder(n: u64) -> impl Fn(u64) -> u64 { move |x| x + n }\n' >> slow/src/lib.rs && + printf 'pub fn two() -> u64 { slow::adder(1)(1) }\n' >> mid/src/lib.rs" +step change-opaque "sed -i.bak 's/move |x| x + n }/move |x| x * n + [0u64; 2].len() as u64 }/' slow/src/lib.rs" +step interface-break "sed -i.bak 's/pub fn make() -> Widget { Widget(busy_0()) }/pub fn make() -> Option { None }/' slow/src/lib.rs" +step interface-fix "sed -i.bak 's/pub fn make() -> Option { None }/pub fn make() -> Widget { Widget(busy_0()) }/' slow/src/lib.rs" +step body-error "printf 'pub fn oops() -> u32 { \"no\" }\n' >> slow/src/lib.rs" +step body-fix "sed -i.bak '/pub fn oops/d' slow/src/lib.rs" +step app-edit "sed -i.bak 's/mid::widget().0/mid::widget().0 + mid::two()/' app/src/main.rs" +step touch-all "touch slow/src/lib.rs mid/src/lib.rs app/src/main.rs" + +# The final incremental state against a clean build of the same sources. +for mode in 0 1; do + (cd "$tmp/ws$mode" && rm -rf target && CARGO_HEADSTART=$mode "$cargo" $command --color never --message-format short 2>&1 | + grep -v -e '^ *Checking ' -e '^ *Compiling ' -e '^ *Finished ' -e '^ *Blocking ' -e 'build failed, waiting for other jobs' > "$tmp/clean.$mode"; echo "exit ${PIPESTATUS[0]}" >> "$tmp/clean.$mode" + if [ $command = build ] && [ -x target/debug/app ]; then target/debug/app >> "$tmp/clean.$mode" 2>&1; fi) +done +if diff -q "$tmp/clean.0" "$tmp/touch-all.1" >/dev/null && diff -q "$tmp/clean.1" "$tmp/touch-all.1" >/dev/null; then + echo "same final state vs clean build" +else + echo "DIFFER final state vs clean build"; diff "$tmp/clean.0" "$tmp/touch-all.1"; diff "$tmp/clean.1" "$tmp/touch-all.1"; status=1 +fi +rm -rf "$tmp" +exit $status diff --git a/scripts/check-swap.sh b/scripts/check-swap.sh new file mode 100755 index 0000000..54476b0 --- /dev/null +++ b/scripts/check-swap.sh @@ -0,0 +1,92 @@ +#!/usr/bin/env bash +# Checks that a library that starts on its dependency's early metadata, and +# pauses for the full metadata before code generation, builds exactly as it +# would from full metadata, at every optimization level: +# +# scripts/check-swap.sh +# +# `dep` is compiled first. Its full metadata and rlib are then hidden, so +# `mid` starts from early metadata, and writes its own early metadata from +# it. They're restored once `mid` announces it's waiting for them. A program +# using `mid` must print the same as when `mid` is built from full metadata. +set -euo pipefail +root="$(cd "$(dirname "$0")/.." && pwd)" +rustc=${RUSTC:-$root/rustc/build/host/stage1/bin/rustc} +work=$(mktemp -d) +trap 'rm -rf "$work"' EXIT + +cat > "$work/dep.rs" <<'EOF' +pub fn small(x: u32) -> u32 { x + 1 } +pub fn generic() -> String { format!("{:?}", T::default()) } +#[inline] +pub fn hinted(x: u64) -> u64 { x * 3 } +pub async fn later(x: u32) -> u32 { small(x) } +EOF +cat > "$work/mid.rs" <<'EOF' +pub fn poll(f: F) -> F::Output { + let waker = std::task::Waker::noop(); + let mut cx = std::task::Context::from_waker(waker); + let mut f = std::pin::pin!(f); + loop { + if let std::task::Poll::Ready(v) = f.as_mut().poll(&mut cx) { + return v; + } + } +} +pub fn calls() -> String { + format!("{} {} {}", dep::small(1), dep::generic::(), dep::hinted(2)) +} +pub fn run() -> String { + format!("{} {}", calls(), poll(dep::later(4))) +} +EOF +echo 'fn main() { println!("{}", mid::run()); }' > "$work/main.rs" + +status=0 +for opt in 0 1 2 3 s z; do + out=$work/$opt + mkdir -p "$out/hidden" + common=(-Zearly-metadata -C opt-level=$opt --edition=2024 -L "dependency=$out") + lib=(--crate-type lib --emit=metadata,link -C extra-filename=-x --out-dir "$out") + mid=("${lib[@]}" --crate-name mid --extern "dep=$out/libdep-x.rmeta" "$work/mid.rs") + main=(--crate-name main --extern "mid=$out/libmid-x.rlib" "$work/main.rs") + "$rustc" "${common[@]}" "${lib[@]}" --crate-name dep "$work/dep.rs" + + # From full metadata. + "$rustc" "${common[@]}" "${mid[@]}" + "$rustc" "${common[@]}" "${main[@]}" -o "$out/direct" + want=$("$out/direct") + rm -f "$out"/libmid-x.* + + # From early metadata, swapping in the full metadata while paused. + mv "$out/libdep-x.rmeta" "$out/libdep-x.rlib" "$out/hidden/" + log=$out/swap.log + "$rustc" "${common[@]}" "${mid[@]}" -Zearly-metadata-verify \ + --error-format=json --json=artifacts 2> "$log" & + pid=$! + for _ in $(seq 600); do + grep -q '"emit":"wait-metadata"' "$log" && break + kill -0 $pid 2>/dev/null || break + sleep 0.05 + done + paused=$(grep -c '"emit":"wait-metadata"' "$log" || true) + mv "$out/hidden/"* "$out/" + if ! wait $pid; then + echo "opt-level=$opt: build from early metadata failed:" + grep -o '"rendered":"[^"]*' "$log" | head -5 + status=1 + continue + fi + "$rustc" "${common[@]}" "${main[@]}" -o "$out/swapped" + got=$("$out/swapped") + if grep -q '^early-metadata-verify' "$log"; then + echo "opt-level=$opt:"; grep '^early-metadata-verify' "$log" | sort -u; status=1 + elif [ "$paused" = 0 ]; then + echo "opt-level=$opt: never paused"; status=1 + elif [ "$got" != "$want" ]; then + echo "opt-level=$opt: printed '$got', expected '$want'"; status=1 + else + echo "opt-level=$opt: ok ($got)" + fi +done +exit $status diff --git a/scripts/critical-path.py b/scripts/critical-path.py new file mode 100755 index 0000000..5d4942c --- /dev/null +++ b/scripts/critical-path.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +"""Reads event logs from scripts/log-rustc (HEADSTART_LOG) and reports where +the build's time goes along its critical path, plus two headstart-specific +waits: + +- linking crates (binaries, proc macros): how long after their dependencies' + early metadata they started (queued for a job slot, or held by cargo); +- pauses: time spent waiting for a dependency's full metadata or rlib, + split into waiting for the file and waiting after it was written. + +A pause runs from the first `wait-metadata` after a `resume` (rustc +announces each file it waits for) to the next `resume`. The critical path +treats a linking crate as waiting for every rlib it links, which it does +before linking. + + scripts/critical-path.py ... +""" +import sys +from collections import defaultdict + +LINKING = {"bin", "proc-macro", "cdylib", "dylib", "staticlib"} + +def load(path): + units = {} + for line in open(path): + f = line.split() + key, kind, t = f[0], f[1], float(f[2]) + name = key.rsplit(":", 1)[0] + if name == "___": + continue + if kind == "start": + units[key] = {"name": name, "_key": key, "start": t, "type": f[3], + "deps": [] if f[4] == "-" else f[4].split(","), + "events": defaultdict(list)} + elif key in units: + units[key]["events"][kind].append(t) + units[key].setdefault("seq", []).append((kind, t, f[3] if len(f) > 3 else None)) + return units + +def pauses(u): + """(start, resume, files waited for) for each pause of a unit.""" + out, start, files = [], None, [] + for kind, t, f in u.get("seq", []): + if kind == "wait-metadata": + if start is None: + start, files = t, [] + files.append(f) + elif kind == "resume" and start is not None: + out.append((start, t, files)) + start = None + return out + +def first(u, kind): + return u["events"][kind][0] if u["events"][kind] else None + +def report(path): + units = {k: u for k, u in load(path).items()} + units = {k: u for k, u in units.items() if u["events"]["end"]} + by_name = {} + for key, u in units.items(): + by_name.setdefault(u["name"], key) # first run of that name + u["end"] = first(u, "end") + u["early"] = first(u, "early-metadata") + u["full"] = first(u, "metadata") + u["paused"] = sum(r - s for s, r, _ in pauses(u)) + t0 = min(u["start"] for u in units.values()) + end = max(u["end"] for u in units.values() if u["end"]) + def dep_units(u): + return [units[by_name[d]] for d in u["deps"] if d in by_name] + def ancestors(u, seen=None): + seen = set() if seen is None else seen + for d in dep_units(u): + if d["_key"] not in seen: + seen.add(d["_key"]); ancestors(d, seen) + return [units[k] for k in seen] + def early_ready(d): + # When a dependent could start on d: its early (or full) metadata; + # proc macros only once built. + if d["type"] == "proc-macro": + return d["end"] + return d["early"] or d["full"] or d["end"] + print(f"== {path}: {end - t0:.2f} s, {len(units)} rustc runs, " + f"{sum(u['paused'] for u in units.values()):.1f} s paused in total") + # Linking crates held back after their dependencies' early metadata. + held = [] + for u in units.values(): + if u["type"] in LINKING and u["deps"]: + anc = ancestors(u) + could = max([early_ready(d) for d in anc] + [t0]) + held.append((u["start"] - could, u["end"] - u["start"], u["name"], u["type"], + could - t0, u["start"] - t0)) + held.sort(reverse=True) + print(" linking crates, held after dependencies' early metadata " + "(held, own run time, crate):") + for h, run, name, typ, could, start in held[:6]: + print(f" {h:6.2f} s held, runs {run:5.2f} s {name} ({typ}); could start " + f"{could:.2f}, started {start:.2f}") + # Critical path, walked back from the last crate to finish. + u = max((u for u in units.values() if u["end"]), key=lambda u: u["end"]) + path_ = [] + while u: + path_.append(u) + deps = ancestors(u) if u["type"] in LINKING else dep_units(u) + if not deps: + break + if u["type"] in LINKING: + u = max(deps, key=lambda d: d["end"]) + else: + u = max(deps, key=early_ready) + # Pauses: waiting for the awaited files vs. resuming after they were written. + written = {} + for u in units.values(): + for kind, t, f in u.get("seq", []): + if kind in ("metadata", "link") and f: + written[f] = t + waiting = after = 0.0 + for u in units.values(): + for start, resume, files in pauses(u): + ready = max(written.get(f, resume) for f in files) + waiting += max(0.0, min(ready, resume) - start) + after += max(0.0, resume - max(ready, start)) + print(f" paused: {waiting:.1f} s waiting for files, " + f"{after:.1f} s between the last one being written and resuming") + print(" critical path (start, end, paused, crate):") + for u in reversed(path_): + print(f" {u['start'] - t0:6.2f} {u['end'] - t0:6.2f} {u['paused']:5.2f} " + f"{u['name']} ({u['type']})") + +for p in sys.argv[1:]: + report(p) diff --git a/scripts/log-rustc b/scripts/log-rustc new file mode 100755 index 0000000..ec46673 --- /dev/null +++ b/scripts/log-rustc @@ -0,0 +1,38 @@ +#!/usr/bin/env bash +# RUSTC_WRAPPER that logs, to $HEADSTART_LOG, one line per event of each rustc +# run, with times in seconds: +# +# : start +# : +# : end +# +# The id tells apart runs of the same crate name (e.g. build scripts). +# +# Events come from rustc's artifact notifications (`--json=artifacts`), read +# as rustc's stderr passes through unchanged. +rustc="$1"; shift +crate=; prev=; type=bin; deps= +for a in "$@"; do + case $prev in + --crate-name) crate=$a ;; + --crate-type) type=$a ;; + --extern) deps="$deps${deps:+,}${a%%=*}" ;; + esac + prev=$a +done +if [ -z "${HEADSTART_LOG:-}" ] || [ -z "$crate" ]; then exec "$rustc" "$@"; fi +now() { perl -MTime::HiRes=time -e 'printf "%.3f", time'; } +crate=$crate:$$ +echo "$crate start $(now) $type ${deps:--}" >> "$HEADSTART_LOG" +"$rustc" "$@" 2> >(perl -MTime::HiRes=time -ne ' + BEGIN { $| = 1; open(LOG, ">>", $ENV{HEADSTART_LOG}) or die; select((select(LOG), $| = 1)[0]); } + print STDERR $_; + if (/"\$message_type":"artifact"/ && /"emit":"([^"]+)"/) { + my $emit = $1; + my ($file) = /"artifact":"(?:[^"]*\/)?([^"\/]*)"/; + printf LOG "%s %s %.3f %s\n", "'"$crate"'", $emit, time, $file || "-"; + }') +status=$? +wait +echo "$crate end $(now) $status" >> "$HEADSTART_LOG" +exit $status diff --git a/scripts/real-projects.sh b/scripts/real-projects.sh new file mode 100755 index 0000000..f7b86fb --- /dev/null +++ b/scripts/real-projects.sh @@ -0,0 +1,56 @@ +#!/usr/bin/env bash +# Clones the real-world projects used in docs/results.md, at the commits +# measured, into (skipping ones already there), and prints their +# `bench.sh` specs, one per line: +# +# scripts/bench.sh -n 3 -c check $(scripts/real-projects.sh ~/hs-real) +# +# Pass project names after to select some. +set -euo pipefail +root="$(cd "$(dirname "$0")/.." && pwd)" +dir=${1:?usage: $0 [project...]} +shift +mkdir -p "$dir" + +# name, repository, commit, extra cargo arguments (- for none) +projects=" +atuin https://github.com/atuinsh/atuin c319bf20157ee3b3a93c16c9dfa2df03d597f920 - +bevy https://github.com/bevyengine/bevy 92a29e701a6b0bf8846484c3999c2ba97d90dd06 - +helix https://github.com/helix-editor/helix ba40e547426b0f9896c8bdc699a4ab11f2b37dbc - +lemmy https://github.com/LemmyNet/lemmy f1476db8785600db709e6e01df331e00cffbe340 - +lldap https://github.com/lldap/lldap 99c510a7a603df1cdaca00a9ffff95ec73b296eb - +nushell https://github.com/nushell/nushell 2459fdd134ea4fdbae42efd6924e2b41201cf363 - +polars https://github.com/pola-rs/polars 3479b49e806d363fc45d59b387a2dd83de99fb32 - +rust-analyzer https://github.com/rust-lang/rust-analyzer 03fcb77246f2568adb0e9b2fa60d19c6cc1686f4 - +typst https://github.com/typst/typst 9f2b6e8715237cb086899a42873660fe744622e8 - +vaultwarden https://github.com/dani-garcia/vaultwarden 061694d0cb3bbf5d4c7e920c892824f0020cff83 --features=sqlite +wasmtime https://github.com/bytecodealliance/wasmtime a7b4f29596bf686c9293459e29a9d669b79ec503 - +zed https://github.com/zed-industries/zed bd747337d7be138834e20972b9e203c7b239cc47 - +zola https://github.com/getzola/zola 42c89b67214477358a9a4de14f181c474d31a937 - +" + +want=" $* " +echo "$projects" | while read -r name url commit args; do + [ -n "$name" ] || continue + [ $# -eq 0 ] || [[ $want == *" $name "* ]] || continue + dest=$dir/$name + if [ ! -d "$dest" ]; then + # Clone next to the destination, and move it into place when complete. + tmp=$dest.partial + rm -rf "$tmp" + git init -q "$tmp" + git -C "$tmp" fetch -q --depth 1 "$url" "$commit" + git -C "$tmp" checkout -q FETCH_HEAD + # lemmy's email templates are a submodule its build script reads. + # Others (wasmtime's test suites) were measured without theirs. + if [ "$name" = lemmy ]; then + git -C "$tmp" submodule -q update --init --depth 1 + fi + # bevy doesn't commit a lockfile; this is the one it was measured with. + if [ -f "$root/projects/$name.Cargo.lock" ]; then + cp "$root/projects/$name.Cargo.lock" "$tmp/Cargo.lock" + fi + mv "$tmp" "$dest" + fi + if [ "$args" = - ]; then echo "$dest"; else echo "$dest::$args"; fi +done diff --git a/scripts/setup.sh b/scripts/setup.sh new file mode 100755 index 0000000..08bd624 --- /dev/null +++ b/scripts/setup.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env bash +# Check out the pinned rustc and cargo, apply headstart's patches, install +# the rustc build config, and build both tools: +# +# scripts/setup.sh +# +# Afterwards: rustc/build/host/stage1/bin/rustc and cargo/target/release/cargo. +set -euo pipefail +root="$(cd "$(dirname "$0")/.." && pwd)" +cd "$root" +git submodule update --init --depth 1 rustc cargo + +apply() { # + if [ -n "$(git -C "$1" status --porcelain --untracked-files=no)" ]; then + echo "$1/ has local changes; not re-applying patches over them." >&2 + echo "Inspect them with: git -C $1 diff" >&2 + return + fi + for patch in "$2"/*.patch; do + echo "applying $patch" + git -C "$1" apply "$root/$patch" + done +} +apply rustc patches/rustc +apply cargo patches/cargo +cp config/bootstrap.toml rustc/bootstrap.toml + +(cd rustc && ./x build --stage 1 compiler library) +# The pinned cargo needs Rust 1.98 or newer to build. +(cd cargo && cargo "+${HEADSTART_TOOLCHAIN:-1.98.0}" build --release) +echo "ready: rustc/build/host/stage1/bin/rustc, cargo/target/release/cargo" diff --git a/scripts/sweep.sh b/scripts/sweep.sh new file mode 100755 index 0000000..900e516 --- /dev/null +++ b/scripts/sweep.sh @@ -0,0 +1,54 @@ +#!/usr/bin/env bash +# Correctness sweep: builds every rustc-perf compile benchmark (53, not +# counting the -new-solver, -nll, -tiny and -threads4 variants of others) +# once with headstart off and on, with -Zearly-metadata-verify, and checks that every +# build succeeds in both modes with the same diagnostics, and that verify +# reports nothing. +# +# scripts/sweep.sh [-c check|build] [-r] [-t] [-o out-dir] +# +# -r release profile (optimized dependencies, proc macros, build scripts) +# -t parallel front end (-Zthreads=8) +# -o output directory, replaced if it exists (default results/sweep-...) +# +# stm32f4 needs a device feature and fails in both modes; it's reported but +# doesn't fail the sweep. Needs the rustc-perf submodule: +# git -C rustc submodule update --init --depth 1 src/tools/rustc-perf +set -uo pipefail +root="$(cd "$(dirname "$0")/.." && pwd)" +command=check release= threads= out= +while getopts c:rto: opt; do + case $opt in + c) command=$OPTARG ;; r) release=1 ;; t) threads=1 ;; o) out=$OPTARG ;; + *) exit 2 ;; + esac +done +shift $((OPTIND - 1)) +usage="usage: $0 [-c check|build] [-r] [-t] [-o out-dir]" +[ $# -eq 0 ] || { echo "$usage" >&2; exit 2; } +case $command in check|build) ;; *) echo "$usage" >&2; exit 2 ;; esac +name=sweep-$command${release:+-release}${threads:+-threads} +out=${out:-$root/results/$name} +rm -rf "$out" +mkdir -p "$out" + +benchmarks=$root/rustc/src/tools/rustc-perf/collector/compile-benchmarks +specs=() +for d in "$benchmarks"/*/; do + d=${d%/} + # Variants of other benchmarks that only change compiler flags. + basename "$d" | grep -qE -- '-new-solver$|-nll$|-tiny$|-threads4$' && continue + [ -f "$d/Cargo.toml" ] || continue + specs+=("$d${release:+::--release}") +done +[ ${#specs[@]} -gt 0 ] || { echo "no benchmarks under $benchmarks" >&2; exit 2; } + +RUSTFLAGS="-Zearly-metadata-verify${threads:+ -Zthreads=8}" \ + "$root/scripts/bench.sh" -n 1 -c "$command" -o "$out" "${specs[@]}" > "$out.log" 2>&1 + +failed=$(awk -F'\t' 'NR > 1 && $5 != 0 && $1 !~ /^stm32f4/' "$out/runs.tsv" | wc -l) +differ=$(grep '^diagnostics differ' "$out.log" | sed 's/.*: //' | tr ',' '\n' | tr -d ' ' | + grep -v '^stm32f4' | paste -sd, -) +verify=$(cat "$out"/schedules/*.err 2>/dev/null | grep -c '^early-metadata-verify') +echo "$name: $(($(wc -l < "$out/runs.tsv") - 1)) builds, $failed failed, diagnostics differ: ${differ:-none}, verify reports: $verify" +[ "$failed" = 0 ] && [ -z "$differ" ] && [ "$verify" = 0 ] diff --git a/tests/errors/Cargo.lock b/tests/errors/Cargo.lock new file mode 100644 index 0000000..8978f96 --- /dev/null +++ b/tests/errors/Cargo.lock @@ -0,0 +1,21 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "app" +version = "0.1.0" +dependencies = [ + "mid", +] + +[[package]] +name = "mid" +version = "0.1.0" +dependencies = [ + "slow", +] + +[[package]] +name = "slow" +version = "0.1.0" diff --git a/tests/errors/Cargo.toml b/tests/errors/Cargo.toml new file mode 100644 index 0000000..3fa4509 --- /dev/null +++ b/tests/errors/Cargo.toml @@ -0,0 +1,6 @@ +# Failure behavior: `slow` checks its bodies for several seconds, `mid` and +# `app` start on its early metadata. `--features slow/broken` puts an error +# in one of `slow`'s bodies; `--features app/broken` puts one in `app`. +[workspace] +members = ["slow", "mid", "app"] +resolver = "2" diff --git a/tests/errors/app/Cargo.toml b/tests/errors/app/Cargo.toml new file mode 100644 index 0000000..574ac5b --- /dev/null +++ b/tests/errors/app/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "app" +version = "0.1.0" +edition = "2021" + +[features] +broken = [] + +[dependencies] +mid = { path = "../mid" } diff --git a/tests/errors/app/src/main.rs b/tests/errors/app/src/main.rs new file mode 100644 index 0000000..c27526e --- /dev/null +++ b/tests/errors/app/src/main.rs @@ -0,0 +1,9 @@ +fn main() { + let unused = 1; // always a warning + println!("{}", mid::widget().0); +} + +#[cfg(feature = "broken")] +fn broken() -> u32 { + "not a number" +} diff --git a/tests/errors/mid/Cargo.toml b/tests/errors/mid/Cargo.toml new file mode 100644 index 0000000..ae9f913 --- /dev/null +++ b/tests/errors/mid/Cargo.toml @@ -0,0 +1,7 @@ +[package] +name = "mid" +version = "0.1.0" +edition = "2021" + +[dependencies] +slow = { path = "../slow" } diff --git a/tests/errors/mid/src/lib.rs b/tests/errors/mid/src/lib.rs new file mode 100644 index 0000000..b66fc3c --- /dev/null +++ b/tests/errors/mid/src/lib.rs @@ -0,0 +1,3 @@ +pub fn widget() -> slow::Widget { + slow::make() +} diff --git a/tests/errors/slow/Cargo.toml b/tests/errors/slow/Cargo.toml new file mode 100644 index 0000000..aaedf67 --- /dev/null +++ b/tests/errors/slow/Cargo.toml @@ -0,0 +1,7 @@ +[package] +name = "slow" +version = "0.1.0" +edition = "2021" + +[features] +broken = [] diff --git a/tests/errors/slow/src/lib.rs b/tests/errors/slow/src/lib.rs new file mode 100644 index 0000000..e2b1190 --- /dev/null +++ b/tests/errors/slow/src/lib.rs @@ -0,0 +1,87 @@ +pub struct Widget(pub u64); + +pub fn make() -> Widget { Widget(busy_0()) } + +#[cfg(feature = "broken")] +pub fn broken() -> u32 { "not a number" } + +pub fn busy_0() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(0)).map(|x| x.wrapping_mul(4).wrapping_add(0)).map(|x| x.wrapping_mul(5).wrapping_add(0)).map(|x| x.wrapping_mul(6).wrapping_add(0)).map(|x| x.wrapping_mul(7).wrapping_add(0)).map(|x| x.wrapping_mul(8).wrapping_add(0)).map(|x| x.wrapping_mul(9).wrapping_add(0)).map(|x| x.wrapping_mul(10).wrapping_add(0)).map(|x| x.wrapping_mul(11).wrapping_add(0)).map(|x| x.wrapping_mul(12).wrapping_add(0)).map(|x| x.wrapping_mul(13).wrapping_add(0)).map(|x| x.wrapping_mul(14).wrapping_add(0)).map(|x| x.wrapping_mul(15).wrapping_add(0)).map(|x| x.wrapping_mul(16).wrapping_add(0)).map(|x| x.wrapping_mul(17).wrapping_add(0)).map(|x| x.wrapping_mul(18).wrapping_add(0)).map(|x| x.wrapping_mul(19).wrapping_add(0)).map(|x| x.wrapping_mul(20).wrapping_add(0)).map(|x| x.wrapping_mul(21).wrapping_add(0)).map(|x| x.wrapping_mul(22).wrapping_add(0)).map(|x| x.wrapping_mul(23).wrapping_add(0)).map(|x| x.wrapping_mul(24).wrapping_add(0)).map(|x| x.wrapping_mul(25).wrapping_add(0)).map(|x| x.wrapping_mul(26).wrapping_add(0)).map(|x| x.wrapping_mul(27).wrapping_add(0)).map(|x| x.wrapping_mul(28).wrapping_add(0)).map(|x| x.wrapping_mul(29).wrapping_add(0)).map(|x| x.wrapping_mul(30).wrapping_add(0)).map(|x| x.wrapping_mul(31).wrapping_add(0)).map(|x| x.wrapping_mul(32).wrapping_add(0)).map(|x| x.wrapping_mul(33).wrapping_add(0)).map(|x| x.wrapping_mul(34).wrapping_add(0)).map(|x| x.wrapping_mul(35).wrapping_add(0)).map(|x| x.wrapping_mul(36).wrapping_add(0)).map(|x| x.wrapping_mul(37).wrapping_add(0)).map(|x| x.wrapping_mul(38).wrapping_add(0)).map(|x| x.wrapping_mul(39).wrapping_add(0)).map(|x| x.wrapping_mul(40).wrapping_add(0)).map(|x| x.wrapping_mul(41).wrapping_add(0)).map(|x| x.wrapping_mul(42).wrapping_add(0)).fold(0, u64::wrapping_add) } +pub fn busy_1() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(1)).map(|x| x.wrapping_mul(4).wrapping_add(1)).map(|x| x.wrapping_mul(5).wrapping_add(1)).map(|x| x.wrapping_mul(6).wrapping_add(1)).map(|x| x.wrapping_mul(7).wrapping_add(1)).map(|x| x.wrapping_mul(8).wrapping_add(1)).map(|x| x.wrapping_mul(9).wrapping_add(1)).map(|x| x.wrapping_mul(10).wrapping_add(1)).map(|x| x.wrapping_mul(11).wrapping_add(1)).map(|x| x.wrapping_mul(12).wrapping_add(1)).map(|x| x.wrapping_mul(13).wrapping_add(1)).map(|x| x.wrapping_mul(14).wrapping_add(1)).map(|x| x.wrapping_mul(15).wrapping_add(1)).map(|x| x.wrapping_mul(16).wrapping_add(1)).map(|x| x.wrapping_mul(17).wrapping_add(1)).map(|x| x.wrapping_mul(18).wrapping_add(1)).map(|x| x.wrapping_mul(19).wrapping_add(1)).map(|x| x.wrapping_mul(20).wrapping_add(1)).map(|x| x.wrapping_mul(21).wrapping_add(1)).map(|x| x.wrapping_mul(22).wrapping_add(1)).map(|x| x.wrapping_mul(23).wrapping_add(1)).map(|x| x.wrapping_mul(24).wrapping_add(1)).map(|x| x.wrapping_mul(25).wrapping_add(1)).map(|x| x.wrapping_mul(26).wrapping_add(1)).map(|x| x.wrapping_mul(27).wrapping_add(1)).map(|x| x.wrapping_mul(28).wrapping_add(1)).map(|x| x.wrapping_mul(29).wrapping_add(1)).map(|x| x.wrapping_mul(30).wrapping_add(1)).map(|x| x.wrapping_mul(31).wrapping_add(1)).map(|x| x.wrapping_mul(32).wrapping_add(1)).map(|x| x.wrapping_mul(33).wrapping_add(1)).map(|x| x.wrapping_mul(34).wrapping_add(1)).map(|x| x.wrapping_mul(35).wrapping_add(1)).map(|x| x.wrapping_mul(36).wrapping_add(1)).map(|x| x.wrapping_mul(37).wrapping_add(1)).map(|x| x.wrapping_mul(38).wrapping_add(1)).map(|x| x.wrapping_mul(39).wrapping_add(1)).map(|x| x.wrapping_mul(40).wrapping_add(1)).map(|x| x.wrapping_mul(41).wrapping_add(1)).map(|x| x.wrapping_mul(42).wrapping_add(1)).fold(0, u64::wrapping_add) } +pub fn busy_2() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(2)).map(|x| x.wrapping_mul(4).wrapping_add(2)).map(|x| x.wrapping_mul(5).wrapping_add(2)).map(|x| x.wrapping_mul(6).wrapping_add(2)).map(|x| x.wrapping_mul(7).wrapping_add(2)).map(|x| x.wrapping_mul(8).wrapping_add(2)).map(|x| x.wrapping_mul(9).wrapping_add(2)).map(|x| x.wrapping_mul(10).wrapping_add(2)).map(|x| x.wrapping_mul(11).wrapping_add(2)).map(|x| x.wrapping_mul(12).wrapping_add(2)).map(|x| x.wrapping_mul(13).wrapping_add(2)).map(|x| x.wrapping_mul(14).wrapping_add(2)).map(|x| x.wrapping_mul(15).wrapping_add(2)).map(|x| x.wrapping_mul(16).wrapping_add(2)).map(|x| x.wrapping_mul(17).wrapping_add(2)).map(|x| x.wrapping_mul(18).wrapping_add(2)).map(|x| x.wrapping_mul(19).wrapping_add(2)).map(|x| x.wrapping_mul(20).wrapping_add(2)).map(|x| x.wrapping_mul(21).wrapping_add(2)).map(|x| x.wrapping_mul(22).wrapping_add(2)).map(|x| x.wrapping_mul(23).wrapping_add(2)).map(|x| x.wrapping_mul(24).wrapping_add(2)).map(|x| x.wrapping_mul(25).wrapping_add(2)).map(|x| x.wrapping_mul(26).wrapping_add(2)).map(|x| x.wrapping_mul(27).wrapping_add(2)).map(|x| x.wrapping_mul(28).wrapping_add(2)).map(|x| x.wrapping_mul(29).wrapping_add(2)).map(|x| x.wrapping_mul(30).wrapping_add(2)).map(|x| x.wrapping_mul(31).wrapping_add(2)).map(|x| x.wrapping_mul(32).wrapping_add(2)).map(|x| x.wrapping_mul(33).wrapping_add(2)).map(|x| x.wrapping_mul(34).wrapping_add(2)).map(|x| x.wrapping_mul(35).wrapping_add(2)).map(|x| x.wrapping_mul(36).wrapping_add(2)).map(|x| x.wrapping_mul(37).wrapping_add(2)).map(|x| x.wrapping_mul(38).wrapping_add(2)).map(|x| x.wrapping_mul(39).wrapping_add(2)).map(|x| x.wrapping_mul(40).wrapping_add(2)).map(|x| x.wrapping_mul(41).wrapping_add(2)).map(|x| x.wrapping_mul(42).wrapping_add(2)).fold(0, u64::wrapping_add) } +pub fn busy_3() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(3)).map(|x| x.wrapping_mul(4).wrapping_add(3)).map(|x| x.wrapping_mul(5).wrapping_add(3)).map(|x| x.wrapping_mul(6).wrapping_add(3)).map(|x| x.wrapping_mul(7).wrapping_add(3)).map(|x| x.wrapping_mul(8).wrapping_add(3)).map(|x| x.wrapping_mul(9).wrapping_add(3)).map(|x| x.wrapping_mul(10).wrapping_add(3)).map(|x| x.wrapping_mul(11).wrapping_add(3)).map(|x| x.wrapping_mul(12).wrapping_add(3)).map(|x| x.wrapping_mul(13).wrapping_add(3)).map(|x| x.wrapping_mul(14).wrapping_add(3)).map(|x| x.wrapping_mul(15).wrapping_add(3)).map(|x| x.wrapping_mul(16).wrapping_add(3)).map(|x| x.wrapping_mul(17).wrapping_add(3)).map(|x| x.wrapping_mul(18).wrapping_add(3)).map(|x| x.wrapping_mul(19).wrapping_add(3)).map(|x| x.wrapping_mul(20).wrapping_add(3)).map(|x| x.wrapping_mul(21).wrapping_add(3)).map(|x| x.wrapping_mul(22).wrapping_add(3)).map(|x| x.wrapping_mul(23).wrapping_add(3)).map(|x| x.wrapping_mul(24).wrapping_add(3)).map(|x| x.wrapping_mul(25).wrapping_add(3)).map(|x| x.wrapping_mul(26).wrapping_add(3)).map(|x| x.wrapping_mul(27).wrapping_add(3)).map(|x| x.wrapping_mul(28).wrapping_add(3)).map(|x| x.wrapping_mul(29).wrapping_add(3)).map(|x| x.wrapping_mul(30).wrapping_add(3)).map(|x| x.wrapping_mul(31).wrapping_add(3)).map(|x| x.wrapping_mul(32).wrapping_add(3)).map(|x| x.wrapping_mul(33).wrapping_add(3)).map(|x| x.wrapping_mul(34).wrapping_add(3)).map(|x| x.wrapping_mul(35).wrapping_add(3)).map(|x| x.wrapping_mul(36).wrapping_add(3)).map(|x| x.wrapping_mul(37).wrapping_add(3)).map(|x| x.wrapping_mul(38).wrapping_add(3)).map(|x| x.wrapping_mul(39).wrapping_add(3)).map(|x| x.wrapping_mul(40).wrapping_add(3)).map(|x| x.wrapping_mul(41).wrapping_add(3)).map(|x| x.wrapping_mul(42).wrapping_add(3)).fold(0, u64::wrapping_add) } +pub fn busy_4() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(4)).map(|x| x.wrapping_mul(4).wrapping_add(4)).map(|x| x.wrapping_mul(5).wrapping_add(4)).map(|x| x.wrapping_mul(6).wrapping_add(4)).map(|x| x.wrapping_mul(7).wrapping_add(4)).map(|x| x.wrapping_mul(8).wrapping_add(4)).map(|x| x.wrapping_mul(9).wrapping_add(4)).map(|x| x.wrapping_mul(10).wrapping_add(4)).map(|x| x.wrapping_mul(11).wrapping_add(4)).map(|x| x.wrapping_mul(12).wrapping_add(4)).map(|x| x.wrapping_mul(13).wrapping_add(4)).map(|x| x.wrapping_mul(14).wrapping_add(4)).map(|x| x.wrapping_mul(15).wrapping_add(4)).map(|x| x.wrapping_mul(16).wrapping_add(4)).map(|x| x.wrapping_mul(17).wrapping_add(4)).map(|x| x.wrapping_mul(18).wrapping_add(4)).map(|x| x.wrapping_mul(19).wrapping_add(4)).map(|x| x.wrapping_mul(20).wrapping_add(4)).map(|x| x.wrapping_mul(21).wrapping_add(4)).map(|x| x.wrapping_mul(22).wrapping_add(4)).map(|x| x.wrapping_mul(23).wrapping_add(4)).map(|x| x.wrapping_mul(24).wrapping_add(4)).map(|x| x.wrapping_mul(25).wrapping_add(4)).map(|x| x.wrapping_mul(26).wrapping_add(4)).map(|x| x.wrapping_mul(27).wrapping_add(4)).map(|x| x.wrapping_mul(28).wrapping_add(4)).map(|x| x.wrapping_mul(29).wrapping_add(4)).map(|x| x.wrapping_mul(30).wrapping_add(4)).map(|x| x.wrapping_mul(31).wrapping_add(4)).map(|x| x.wrapping_mul(32).wrapping_add(4)).map(|x| x.wrapping_mul(33).wrapping_add(4)).map(|x| x.wrapping_mul(34).wrapping_add(4)).map(|x| x.wrapping_mul(35).wrapping_add(4)).map(|x| x.wrapping_mul(36).wrapping_add(4)).map(|x| x.wrapping_mul(37).wrapping_add(4)).map(|x| x.wrapping_mul(38).wrapping_add(4)).map(|x| x.wrapping_mul(39).wrapping_add(4)).map(|x| x.wrapping_mul(40).wrapping_add(4)).map(|x| x.wrapping_mul(41).wrapping_add(4)).map(|x| x.wrapping_mul(42).wrapping_add(4)).fold(0, u64::wrapping_add) } +pub fn busy_5() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(5)).map(|x| x.wrapping_mul(4).wrapping_add(5)).map(|x| x.wrapping_mul(5).wrapping_add(5)).map(|x| x.wrapping_mul(6).wrapping_add(5)).map(|x| x.wrapping_mul(7).wrapping_add(5)).map(|x| x.wrapping_mul(8).wrapping_add(5)).map(|x| x.wrapping_mul(9).wrapping_add(5)).map(|x| x.wrapping_mul(10).wrapping_add(5)).map(|x| x.wrapping_mul(11).wrapping_add(5)).map(|x| x.wrapping_mul(12).wrapping_add(5)).map(|x| x.wrapping_mul(13).wrapping_add(5)).map(|x| x.wrapping_mul(14).wrapping_add(5)).map(|x| x.wrapping_mul(15).wrapping_add(5)).map(|x| x.wrapping_mul(16).wrapping_add(5)).map(|x| x.wrapping_mul(17).wrapping_add(5)).map(|x| x.wrapping_mul(18).wrapping_add(5)).map(|x| x.wrapping_mul(19).wrapping_add(5)).map(|x| x.wrapping_mul(20).wrapping_add(5)).map(|x| x.wrapping_mul(21).wrapping_add(5)).map(|x| x.wrapping_mul(22).wrapping_add(5)).map(|x| x.wrapping_mul(23).wrapping_add(5)).map(|x| x.wrapping_mul(24).wrapping_add(5)).map(|x| x.wrapping_mul(25).wrapping_add(5)).map(|x| x.wrapping_mul(26).wrapping_add(5)).map(|x| x.wrapping_mul(27).wrapping_add(5)).map(|x| x.wrapping_mul(28).wrapping_add(5)).map(|x| x.wrapping_mul(29).wrapping_add(5)).map(|x| x.wrapping_mul(30).wrapping_add(5)).map(|x| x.wrapping_mul(31).wrapping_add(5)).map(|x| x.wrapping_mul(32).wrapping_add(5)).map(|x| x.wrapping_mul(33).wrapping_add(5)).map(|x| x.wrapping_mul(34).wrapping_add(5)).map(|x| x.wrapping_mul(35).wrapping_add(5)).map(|x| x.wrapping_mul(36).wrapping_add(5)).map(|x| x.wrapping_mul(37).wrapping_add(5)).map(|x| x.wrapping_mul(38).wrapping_add(5)).map(|x| x.wrapping_mul(39).wrapping_add(5)).map(|x| x.wrapping_mul(40).wrapping_add(5)).map(|x| x.wrapping_mul(41).wrapping_add(5)).map(|x| x.wrapping_mul(42).wrapping_add(5)).fold(0, u64::wrapping_add) } +pub fn busy_6() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(6)).map(|x| x.wrapping_mul(4).wrapping_add(6)).map(|x| x.wrapping_mul(5).wrapping_add(6)).map(|x| x.wrapping_mul(6).wrapping_add(6)).map(|x| x.wrapping_mul(7).wrapping_add(6)).map(|x| x.wrapping_mul(8).wrapping_add(6)).map(|x| x.wrapping_mul(9).wrapping_add(6)).map(|x| x.wrapping_mul(10).wrapping_add(6)).map(|x| x.wrapping_mul(11).wrapping_add(6)).map(|x| x.wrapping_mul(12).wrapping_add(6)).map(|x| x.wrapping_mul(13).wrapping_add(6)).map(|x| x.wrapping_mul(14).wrapping_add(6)).map(|x| x.wrapping_mul(15).wrapping_add(6)).map(|x| x.wrapping_mul(16).wrapping_add(6)).map(|x| x.wrapping_mul(17).wrapping_add(6)).map(|x| x.wrapping_mul(18).wrapping_add(6)).map(|x| x.wrapping_mul(19).wrapping_add(6)).map(|x| x.wrapping_mul(20).wrapping_add(6)).map(|x| x.wrapping_mul(21).wrapping_add(6)).map(|x| x.wrapping_mul(22).wrapping_add(6)).map(|x| x.wrapping_mul(23).wrapping_add(6)).map(|x| x.wrapping_mul(24).wrapping_add(6)).map(|x| x.wrapping_mul(25).wrapping_add(6)).map(|x| x.wrapping_mul(26).wrapping_add(6)).map(|x| x.wrapping_mul(27).wrapping_add(6)).map(|x| x.wrapping_mul(28).wrapping_add(6)).map(|x| x.wrapping_mul(29).wrapping_add(6)).map(|x| x.wrapping_mul(30).wrapping_add(6)).map(|x| x.wrapping_mul(31).wrapping_add(6)).map(|x| x.wrapping_mul(32).wrapping_add(6)).map(|x| x.wrapping_mul(33).wrapping_add(6)).map(|x| x.wrapping_mul(34).wrapping_add(6)).map(|x| x.wrapping_mul(35).wrapping_add(6)).map(|x| x.wrapping_mul(36).wrapping_add(6)).map(|x| x.wrapping_mul(37).wrapping_add(6)).map(|x| x.wrapping_mul(38).wrapping_add(6)).map(|x| x.wrapping_mul(39).wrapping_add(6)).map(|x| x.wrapping_mul(40).wrapping_add(6)).map(|x| x.wrapping_mul(41).wrapping_add(6)).map(|x| x.wrapping_mul(42).wrapping_add(6)).fold(0, u64::wrapping_add) } +pub fn busy_7() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(7)).map(|x| x.wrapping_mul(4).wrapping_add(7)).map(|x| x.wrapping_mul(5).wrapping_add(7)).map(|x| x.wrapping_mul(6).wrapping_add(7)).map(|x| x.wrapping_mul(7).wrapping_add(7)).map(|x| x.wrapping_mul(8).wrapping_add(7)).map(|x| x.wrapping_mul(9).wrapping_add(7)).map(|x| x.wrapping_mul(10).wrapping_add(7)).map(|x| x.wrapping_mul(11).wrapping_add(7)).map(|x| x.wrapping_mul(12).wrapping_add(7)).map(|x| x.wrapping_mul(13).wrapping_add(7)).map(|x| x.wrapping_mul(14).wrapping_add(7)).map(|x| x.wrapping_mul(15).wrapping_add(7)).map(|x| x.wrapping_mul(16).wrapping_add(7)).map(|x| x.wrapping_mul(17).wrapping_add(7)).map(|x| x.wrapping_mul(18).wrapping_add(7)).map(|x| x.wrapping_mul(19).wrapping_add(7)).map(|x| x.wrapping_mul(20).wrapping_add(7)).map(|x| x.wrapping_mul(21).wrapping_add(7)).map(|x| x.wrapping_mul(22).wrapping_add(7)).map(|x| x.wrapping_mul(23).wrapping_add(7)).map(|x| x.wrapping_mul(24).wrapping_add(7)).map(|x| x.wrapping_mul(25).wrapping_add(7)).map(|x| x.wrapping_mul(26).wrapping_add(7)).map(|x| x.wrapping_mul(27).wrapping_add(7)).map(|x| x.wrapping_mul(28).wrapping_add(7)).map(|x| x.wrapping_mul(29).wrapping_add(7)).map(|x| x.wrapping_mul(30).wrapping_add(7)).map(|x| x.wrapping_mul(31).wrapping_add(7)).map(|x| x.wrapping_mul(32).wrapping_add(7)).map(|x| x.wrapping_mul(33).wrapping_add(7)).map(|x| x.wrapping_mul(34).wrapping_add(7)).map(|x| x.wrapping_mul(35).wrapping_add(7)).map(|x| x.wrapping_mul(36).wrapping_add(7)).map(|x| x.wrapping_mul(37).wrapping_add(7)).map(|x| x.wrapping_mul(38).wrapping_add(7)).map(|x| x.wrapping_mul(39).wrapping_add(7)).map(|x| x.wrapping_mul(40).wrapping_add(7)).map(|x| x.wrapping_mul(41).wrapping_add(7)).map(|x| x.wrapping_mul(42).wrapping_add(7)).fold(0, u64::wrapping_add) } +pub fn busy_8() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(8)).map(|x| x.wrapping_mul(4).wrapping_add(8)).map(|x| x.wrapping_mul(5).wrapping_add(8)).map(|x| x.wrapping_mul(6).wrapping_add(8)).map(|x| x.wrapping_mul(7).wrapping_add(8)).map(|x| x.wrapping_mul(8).wrapping_add(8)).map(|x| x.wrapping_mul(9).wrapping_add(8)).map(|x| x.wrapping_mul(10).wrapping_add(8)).map(|x| x.wrapping_mul(11).wrapping_add(8)).map(|x| x.wrapping_mul(12).wrapping_add(8)).map(|x| x.wrapping_mul(13).wrapping_add(8)).map(|x| x.wrapping_mul(14).wrapping_add(8)).map(|x| x.wrapping_mul(15).wrapping_add(8)).map(|x| x.wrapping_mul(16).wrapping_add(8)).map(|x| x.wrapping_mul(17).wrapping_add(8)).map(|x| x.wrapping_mul(18).wrapping_add(8)).map(|x| x.wrapping_mul(19).wrapping_add(8)).map(|x| x.wrapping_mul(20).wrapping_add(8)).map(|x| x.wrapping_mul(21).wrapping_add(8)).map(|x| x.wrapping_mul(22).wrapping_add(8)).map(|x| x.wrapping_mul(23).wrapping_add(8)).map(|x| x.wrapping_mul(24).wrapping_add(8)).map(|x| x.wrapping_mul(25).wrapping_add(8)).map(|x| x.wrapping_mul(26).wrapping_add(8)).map(|x| x.wrapping_mul(27).wrapping_add(8)).map(|x| x.wrapping_mul(28).wrapping_add(8)).map(|x| x.wrapping_mul(29).wrapping_add(8)).map(|x| x.wrapping_mul(30).wrapping_add(8)).map(|x| x.wrapping_mul(31).wrapping_add(8)).map(|x| x.wrapping_mul(32).wrapping_add(8)).map(|x| x.wrapping_mul(33).wrapping_add(8)).map(|x| x.wrapping_mul(34).wrapping_add(8)).map(|x| x.wrapping_mul(35).wrapping_add(8)).map(|x| x.wrapping_mul(36).wrapping_add(8)).map(|x| x.wrapping_mul(37).wrapping_add(8)).map(|x| x.wrapping_mul(38).wrapping_add(8)).map(|x| x.wrapping_mul(39).wrapping_add(8)).map(|x| x.wrapping_mul(40).wrapping_add(8)).map(|x| x.wrapping_mul(41).wrapping_add(8)).map(|x| x.wrapping_mul(42).wrapping_add(8)).fold(0, u64::wrapping_add) } +pub fn busy_9() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(9)).map(|x| x.wrapping_mul(4).wrapping_add(9)).map(|x| x.wrapping_mul(5).wrapping_add(9)).map(|x| x.wrapping_mul(6).wrapping_add(9)).map(|x| x.wrapping_mul(7).wrapping_add(9)).map(|x| x.wrapping_mul(8).wrapping_add(9)).map(|x| x.wrapping_mul(9).wrapping_add(9)).map(|x| x.wrapping_mul(10).wrapping_add(9)).map(|x| x.wrapping_mul(11).wrapping_add(9)).map(|x| x.wrapping_mul(12).wrapping_add(9)).map(|x| x.wrapping_mul(13).wrapping_add(9)).map(|x| x.wrapping_mul(14).wrapping_add(9)).map(|x| x.wrapping_mul(15).wrapping_add(9)).map(|x| x.wrapping_mul(16).wrapping_add(9)).map(|x| x.wrapping_mul(17).wrapping_add(9)).map(|x| x.wrapping_mul(18).wrapping_add(9)).map(|x| x.wrapping_mul(19).wrapping_add(9)).map(|x| x.wrapping_mul(20).wrapping_add(9)).map(|x| x.wrapping_mul(21).wrapping_add(9)).map(|x| x.wrapping_mul(22).wrapping_add(9)).map(|x| x.wrapping_mul(23).wrapping_add(9)).map(|x| x.wrapping_mul(24).wrapping_add(9)).map(|x| x.wrapping_mul(25).wrapping_add(9)).map(|x| x.wrapping_mul(26).wrapping_add(9)).map(|x| x.wrapping_mul(27).wrapping_add(9)).map(|x| x.wrapping_mul(28).wrapping_add(9)).map(|x| x.wrapping_mul(29).wrapping_add(9)).map(|x| x.wrapping_mul(30).wrapping_add(9)).map(|x| x.wrapping_mul(31).wrapping_add(9)).map(|x| x.wrapping_mul(32).wrapping_add(9)).map(|x| x.wrapping_mul(33).wrapping_add(9)).map(|x| x.wrapping_mul(34).wrapping_add(9)).map(|x| x.wrapping_mul(35).wrapping_add(9)).map(|x| x.wrapping_mul(36).wrapping_add(9)).map(|x| x.wrapping_mul(37).wrapping_add(9)).map(|x| x.wrapping_mul(38).wrapping_add(9)).map(|x| x.wrapping_mul(39).wrapping_add(9)).map(|x| x.wrapping_mul(40).wrapping_add(9)).map(|x| x.wrapping_mul(41).wrapping_add(9)).map(|x| x.wrapping_mul(42).wrapping_add(9)).fold(0, u64::wrapping_add) } +pub fn busy_10() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(10)).map(|x| x.wrapping_mul(4).wrapping_add(10)).map(|x| x.wrapping_mul(5).wrapping_add(10)).map(|x| x.wrapping_mul(6).wrapping_add(10)).map(|x| x.wrapping_mul(7).wrapping_add(10)).map(|x| x.wrapping_mul(8).wrapping_add(10)).map(|x| x.wrapping_mul(9).wrapping_add(10)).map(|x| x.wrapping_mul(10).wrapping_add(10)).map(|x| x.wrapping_mul(11).wrapping_add(10)).map(|x| x.wrapping_mul(12).wrapping_add(10)).map(|x| x.wrapping_mul(13).wrapping_add(10)).map(|x| x.wrapping_mul(14).wrapping_add(10)).map(|x| x.wrapping_mul(15).wrapping_add(10)).map(|x| x.wrapping_mul(16).wrapping_add(10)).map(|x| x.wrapping_mul(17).wrapping_add(10)).map(|x| x.wrapping_mul(18).wrapping_add(10)).map(|x| x.wrapping_mul(19).wrapping_add(10)).map(|x| x.wrapping_mul(20).wrapping_add(10)).map(|x| x.wrapping_mul(21).wrapping_add(10)).map(|x| x.wrapping_mul(22).wrapping_add(10)).map(|x| x.wrapping_mul(23).wrapping_add(10)).map(|x| x.wrapping_mul(24).wrapping_add(10)).map(|x| x.wrapping_mul(25).wrapping_add(10)).map(|x| x.wrapping_mul(26).wrapping_add(10)).map(|x| x.wrapping_mul(27).wrapping_add(10)).map(|x| x.wrapping_mul(28).wrapping_add(10)).map(|x| x.wrapping_mul(29).wrapping_add(10)).map(|x| x.wrapping_mul(30).wrapping_add(10)).map(|x| x.wrapping_mul(31).wrapping_add(10)).map(|x| x.wrapping_mul(32).wrapping_add(10)).map(|x| x.wrapping_mul(33).wrapping_add(10)).map(|x| x.wrapping_mul(34).wrapping_add(10)).map(|x| x.wrapping_mul(35).wrapping_add(10)).map(|x| x.wrapping_mul(36).wrapping_add(10)).map(|x| x.wrapping_mul(37).wrapping_add(10)).map(|x| x.wrapping_mul(38).wrapping_add(10)).map(|x| x.wrapping_mul(39).wrapping_add(10)).map(|x| x.wrapping_mul(40).wrapping_add(10)).map(|x| x.wrapping_mul(41).wrapping_add(10)).map(|x| x.wrapping_mul(42).wrapping_add(10)).fold(0, u64::wrapping_add) } +pub fn busy_11() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(11)).map(|x| x.wrapping_mul(4).wrapping_add(11)).map(|x| x.wrapping_mul(5).wrapping_add(11)).map(|x| x.wrapping_mul(6).wrapping_add(11)).map(|x| x.wrapping_mul(7).wrapping_add(11)).map(|x| x.wrapping_mul(8).wrapping_add(11)).map(|x| x.wrapping_mul(9).wrapping_add(11)).map(|x| x.wrapping_mul(10).wrapping_add(11)).map(|x| x.wrapping_mul(11).wrapping_add(11)).map(|x| x.wrapping_mul(12).wrapping_add(11)).map(|x| x.wrapping_mul(13).wrapping_add(11)).map(|x| x.wrapping_mul(14).wrapping_add(11)).map(|x| x.wrapping_mul(15).wrapping_add(11)).map(|x| x.wrapping_mul(16).wrapping_add(11)).map(|x| x.wrapping_mul(17).wrapping_add(11)).map(|x| x.wrapping_mul(18).wrapping_add(11)).map(|x| x.wrapping_mul(19).wrapping_add(11)).map(|x| x.wrapping_mul(20).wrapping_add(11)).map(|x| x.wrapping_mul(21).wrapping_add(11)).map(|x| x.wrapping_mul(22).wrapping_add(11)).map(|x| x.wrapping_mul(23).wrapping_add(11)).map(|x| x.wrapping_mul(24).wrapping_add(11)).map(|x| x.wrapping_mul(25).wrapping_add(11)).map(|x| x.wrapping_mul(26).wrapping_add(11)).map(|x| x.wrapping_mul(27).wrapping_add(11)).map(|x| x.wrapping_mul(28).wrapping_add(11)).map(|x| x.wrapping_mul(29).wrapping_add(11)).map(|x| x.wrapping_mul(30).wrapping_add(11)).map(|x| x.wrapping_mul(31).wrapping_add(11)).map(|x| x.wrapping_mul(32).wrapping_add(11)).map(|x| x.wrapping_mul(33).wrapping_add(11)).map(|x| x.wrapping_mul(34).wrapping_add(11)).map(|x| x.wrapping_mul(35).wrapping_add(11)).map(|x| x.wrapping_mul(36).wrapping_add(11)).map(|x| x.wrapping_mul(37).wrapping_add(11)).map(|x| x.wrapping_mul(38).wrapping_add(11)).map(|x| x.wrapping_mul(39).wrapping_add(11)).map(|x| x.wrapping_mul(40).wrapping_add(11)).map(|x| x.wrapping_mul(41).wrapping_add(11)).map(|x| x.wrapping_mul(42).wrapping_add(11)).fold(0, u64::wrapping_add) } +pub fn busy_12() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(12)).map(|x| x.wrapping_mul(4).wrapping_add(12)).map(|x| x.wrapping_mul(5).wrapping_add(12)).map(|x| x.wrapping_mul(6).wrapping_add(12)).map(|x| x.wrapping_mul(7).wrapping_add(12)).map(|x| x.wrapping_mul(8).wrapping_add(12)).map(|x| x.wrapping_mul(9).wrapping_add(12)).map(|x| x.wrapping_mul(10).wrapping_add(12)).map(|x| x.wrapping_mul(11).wrapping_add(12)).map(|x| x.wrapping_mul(12).wrapping_add(12)).map(|x| x.wrapping_mul(13).wrapping_add(12)).map(|x| x.wrapping_mul(14).wrapping_add(12)).map(|x| x.wrapping_mul(15).wrapping_add(12)).map(|x| x.wrapping_mul(16).wrapping_add(12)).map(|x| x.wrapping_mul(17).wrapping_add(12)).map(|x| x.wrapping_mul(18).wrapping_add(12)).map(|x| x.wrapping_mul(19).wrapping_add(12)).map(|x| x.wrapping_mul(20).wrapping_add(12)).map(|x| x.wrapping_mul(21).wrapping_add(12)).map(|x| x.wrapping_mul(22).wrapping_add(12)).map(|x| x.wrapping_mul(23).wrapping_add(12)).map(|x| x.wrapping_mul(24).wrapping_add(12)).map(|x| x.wrapping_mul(25).wrapping_add(12)).map(|x| x.wrapping_mul(26).wrapping_add(12)).map(|x| x.wrapping_mul(27).wrapping_add(12)).map(|x| x.wrapping_mul(28).wrapping_add(12)).map(|x| x.wrapping_mul(29).wrapping_add(12)).map(|x| x.wrapping_mul(30).wrapping_add(12)).map(|x| x.wrapping_mul(31).wrapping_add(12)).map(|x| x.wrapping_mul(32).wrapping_add(12)).map(|x| x.wrapping_mul(33).wrapping_add(12)).map(|x| x.wrapping_mul(34).wrapping_add(12)).map(|x| x.wrapping_mul(35).wrapping_add(12)).map(|x| x.wrapping_mul(36).wrapping_add(12)).map(|x| x.wrapping_mul(37).wrapping_add(12)).map(|x| x.wrapping_mul(38).wrapping_add(12)).map(|x| x.wrapping_mul(39).wrapping_add(12)).map(|x| x.wrapping_mul(40).wrapping_add(12)).map(|x| x.wrapping_mul(41).wrapping_add(12)).map(|x| x.wrapping_mul(42).wrapping_add(12)).fold(0, u64::wrapping_add) } +pub fn busy_13() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(13)).map(|x| x.wrapping_mul(4).wrapping_add(13)).map(|x| x.wrapping_mul(5).wrapping_add(13)).map(|x| x.wrapping_mul(6).wrapping_add(13)).map(|x| x.wrapping_mul(7).wrapping_add(13)).map(|x| x.wrapping_mul(8).wrapping_add(13)).map(|x| x.wrapping_mul(9).wrapping_add(13)).map(|x| x.wrapping_mul(10).wrapping_add(13)).map(|x| x.wrapping_mul(11).wrapping_add(13)).map(|x| x.wrapping_mul(12).wrapping_add(13)).map(|x| x.wrapping_mul(13).wrapping_add(13)).map(|x| x.wrapping_mul(14).wrapping_add(13)).map(|x| x.wrapping_mul(15).wrapping_add(13)).map(|x| x.wrapping_mul(16).wrapping_add(13)).map(|x| x.wrapping_mul(17).wrapping_add(13)).map(|x| x.wrapping_mul(18).wrapping_add(13)).map(|x| x.wrapping_mul(19).wrapping_add(13)).map(|x| x.wrapping_mul(20).wrapping_add(13)).map(|x| x.wrapping_mul(21).wrapping_add(13)).map(|x| x.wrapping_mul(22).wrapping_add(13)).map(|x| x.wrapping_mul(23).wrapping_add(13)).map(|x| x.wrapping_mul(24).wrapping_add(13)).map(|x| x.wrapping_mul(25).wrapping_add(13)).map(|x| x.wrapping_mul(26).wrapping_add(13)).map(|x| x.wrapping_mul(27).wrapping_add(13)).map(|x| x.wrapping_mul(28).wrapping_add(13)).map(|x| x.wrapping_mul(29).wrapping_add(13)).map(|x| x.wrapping_mul(30).wrapping_add(13)).map(|x| x.wrapping_mul(31).wrapping_add(13)).map(|x| x.wrapping_mul(32).wrapping_add(13)).map(|x| x.wrapping_mul(33).wrapping_add(13)).map(|x| x.wrapping_mul(34).wrapping_add(13)).map(|x| x.wrapping_mul(35).wrapping_add(13)).map(|x| x.wrapping_mul(36).wrapping_add(13)).map(|x| x.wrapping_mul(37).wrapping_add(13)).map(|x| x.wrapping_mul(38).wrapping_add(13)).map(|x| x.wrapping_mul(39).wrapping_add(13)).map(|x| x.wrapping_mul(40).wrapping_add(13)).map(|x| x.wrapping_mul(41).wrapping_add(13)).map(|x| x.wrapping_mul(42).wrapping_add(13)).fold(0, u64::wrapping_add) } +pub fn busy_14() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(14)).map(|x| x.wrapping_mul(4).wrapping_add(14)).map(|x| x.wrapping_mul(5).wrapping_add(14)).map(|x| x.wrapping_mul(6).wrapping_add(14)).map(|x| x.wrapping_mul(7).wrapping_add(14)).map(|x| x.wrapping_mul(8).wrapping_add(14)).map(|x| x.wrapping_mul(9).wrapping_add(14)).map(|x| x.wrapping_mul(10).wrapping_add(14)).map(|x| x.wrapping_mul(11).wrapping_add(14)).map(|x| x.wrapping_mul(12).wrapping_add(14)).map(|x| x.wrapping_mul(13).wrapping_add(14)).map(|x| x.wrapping_mul(14).wrapping_add(14)).map(|x| x.wrapping_mul(15).wrapping_add(14)).map(|x| x.wrapping_mul(16).wrapping_add(14)).map(|x| x.wrapping_mul(17).wrapping_add(14)).map(|x| x.wrapping_mul(18).wrapping_add(14)).map(|x| x.wrapping_mul(19).wrapping_add(14)).map(|x| x.wrapping_mul(20).wrapping_add(14)).map(|x| x.wrapping_mul(21).wrapping_add(14)).map(|x| x.wrapping_mul(22).wrapping_add(14)).map(|x| x.wrapping_mul(23).wrapping_add(14)).map(|x| x.wrapping_mul(24).wrapping_add(14)).map(|x| x.wrapping_mul(25).wrapping_add(14)).map(|x| x.wrapping_mul(26).wrapping_add(14)).map(|x| x.wrapping_mul(27).wrapping_add(14)).map(|x| x.wrapping_mul(28).wrapping_add(14)).map(|x| x.wrapping_mul(29).wrapping_add(14)).map(|x| x.wrapping_mul(30).wrapping_add(14)).map(|x| x.wrapping_mul(31).wrapping_add(14)).map(|x| x.wrapping_mul(32).wrapping_add(14)).map(|x| x.wrapping_mul(33).wrapping_add(14)).map(|x| x.wrapping_mul(34).wrapping_add(14)).map(|x| x.wrapping_mul(35).wrapping_add(14)).map(|x| x.wrapping_mul(36).wrapping_add(14)).map(|x| x.wrapping_mul(37).wrapping_add(14)).map(|x| x.wrapping_mul(38).wrapping_add(14)).map(|x| x.wrapping_mul(39).wrapping_add(14)).map(|x| x.wrapping_mul(40).wrapping_add(14)).map(|x| x.wrapping_mul(41).wrapping_add(14)).map(|x| x.wrapping_mul(42).wrapping_add(14)).fold(0, u64::wrapping_add) } +pub fn busy_15() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(15)).map(|x| x.wrapping_mul(4).wrapping_add(15)).map(|x| x.wrapping_mul(5).wrapping_add(15)).map(|x| x.wrapping_mul(6).wrapping_add(15)).map(|x| x.wrapping_mul(7).wrapping_add(15)).map(|x| x.wrapping_mul(8).wrapping_add(15)).map(|x| x.wrapping_mul(9).wrapping_add(15)).map(|x| x.wrapping_mul(10).wrapping_add(15)).map(|x| x.wrapping_mul(11).wrapping_add(15)).map(|x| x.wrapping_mul(12).wrapping_add(15)).map(|x| x.wrapping_mul(13).wrapping_add(15)).map(|x| x.wrapping_mul(14).wrapping_add(15)).map(|x| x.wrapping_mul(15).wrapping_add(15)).map(|x| x.wrapping_mul(16).wrapping_add(15)).map(|x| x.wrapping_mul(17).wrapping_add(15)).map(|x| x.wrapping_mul(18).wrapping_add(15)).map(|x| x.wrapping_mul(19).wrapping_add(15)).map(|x| x.wrapping_mul(20).wrapping_add(15)).map(|x| x.wrapping_mul(21).wrapping_add(15)).map(|x| x.wrapping_mul(22).wrapping_add(15)).map(|x| x.wrapping_mul(23).wrapping_add(15)).map(|x| x.wrapping_mul(24).wrapping_add(15)).map(|x| x.wrapping_mul(25).wrapping_add(15)).map(|x| x.wrapping_mul(26).wrapping_add(15)).map(|x| x.wrapping_mul(27).wrapping_add(15)).map(|x| x.wrapping_mul(28).wrapping_add(15)).map(|x| x.wrapping_mul(29).wrapping_add(15)).map(|x| x.wrapping_mul(30).wrapping_add(15)).map(|x| x.wrapping_mul(31).wrapping_add(15)).map(|x| x.wrapping_mul(32).wrapping_add(15)).map(|x| x.wrapping_mul(33).wrapping_add(15)).map(|x| x.wrapping_mul(34).wrapping_add(15)).map(|x| x.wrapping_mul(35).wrapping_add(15)).map(|x| x.wrapping_mul(36).wrapping_add(15)).map(|x| x.wrapping_mul(37).wrapping_add(15)).map(|x| x.wrapping_mul(38).wrapping_add(15)).map(|x| x.wrapping_mul(39).wrapping_add(15)).map(|x| x.wrapping_mul(40).wrapping_add(15)).map(|x| x.wrapping_mul(41).wrapping_add(15)).map(|x| x.wrapping_mul(42).wrapping_add(15)).fold(0, u64::wrapping_add) } +pub fn busy_16() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(16)).map(|x| x.wrapping_mul(4).wrapping_add(16)).map(|x| x.wrapping_mul(5).wrapping_add(16)).map(|x| x.wrapping_mul(6).wrapping_add(16)).map(|x| x.wrapping_mul(7).wrapping_add(16)).map(|x| x.wrapping_mul(8).wrapping_add(16)).map(|x| x.wrapping_mul(9).wrapping_add(16)).map(|x| x.wrapping_mul(10).wrapping_add(16)).map(|x| x.wrapping_mul(11).wrapping_add(16)).map(|x| x.wrapping_mul(12).wrapping_add(16)).map(|x| x.wrapping_mul(13).wrapping_add(16)).map(|x| x.wrapping_mul(14).wrapping_add(16)).map(|x| x.wrapping_mul(15).wrapping_add(16)).map(|x| x.wrapping_mul(16).wrapping_add(16)).map(|x| x.wrapping_mul(17).wrapping_add(16)).map(|x| x.wrapping_mul(18).wrapping_add(16)).map(|x| x.wrapping_mul(19).wrapping_add(16)).map(|x| x.wrapping_mul(20).wrapping_add(16)).map(|x| x.wrapping_mul(21).wrapping_add(16)).map(|x| x.wrapping_mul(22).wrapping_add(16)).map(|x| x.wrapping_mul(23).wrapping_add(16)).map(|x| x.wrapping_mul(24).wrapping_add(16)).map(|x| x.wrapping_mul(25).wrapping_add(16)).map(|x| x.wrapping_mul(26).wrapping_add(16)).map(|x| x.wrapping_mul(27).wrapping_add(16)).map(|x| x.wrapping_mul(28).wrapping_add(16)).map(|x| x.wrapping_mul(29).wrapping_add(16)).map(|x| x.wrapping_mul(30).wrapping_add(16)).map(|x| x.wrapping_mul(31).wrapping_add(16)).map(|x| x.wrapping_mul(32).wrapping_add(16)).map(|x| x.wrapping_mul(33).wrapping_add(16)).map(|x| x.wrapping_mul(34).wrapping_add(16)).map(|x| x.wrapping_mul(35).wrapping_add(16)).map(|x| x.wrapping_mul(36).wrapping_add(16)).map(|x| x.wrapping_mul(37).wrapping_add(16)).map(|x| x.wrapping_mul(38).wrapping_add(16)).map(|x| x.wrapping_mul(39).wrapping_add(16)).map(|x| x.wrapping_mul(40).wrapping_add(16)).map(|x| x.wrapping_mul(41).wrapping_add(16)).map(|x| x.wrapping_mul(42).wrapping_add(16)).fold(0, u64::wrapping_add) } +pub fn busy_17() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(17)).map(|x| x.wrapping_mul(4).wrapping_add(17)).map(|x| x.wrapping_mul(5).wrapping_add(17)).map(|x| x.wrapping_mul(6).wrapping_add(17)).map(|x| x.wrapping_mul(7).wrapping_add(17)).map(|x| x.wrapping_mul(8).wrapping_add(17)).map(|x| x.wrapping_mul(9).wrapping_add(17)).map(|x| x.wrapping_mul(10).wrapping_add(17)).map(|x| x.wrapping_mul(11).wrapping_add(17)).map(|x| x.wrapping_mul(12).wrapping_add(17)).map(|x| x.wrapping_mul(13).wrapping_add(17)).map(|x| x.wrapping_mul(14).wrapping_add(17)).map(|x| x.wrapping_mul(15).wrapping_add(17)).map(|x| x.wrapping_mul(16).wrapping_add(17)).map(|x| x.wrapping_mul(17).wrapping_add(17)).map(|x| x.wrapping_mul(18).wrapping_add(17)).map(|x| x.wrapping_mul(19).wrapping_add(17)).map(|x| x.wrapping_mul(20).wrapping_add(17)).map(|x| x.wrapping_mul(21).wrapping_add(17)).map(|x| x.wrapping_mul(22).wrapping_add(17)).map(|x| x.wrapping_mul(23).wrapping_add(17)).map(|x| x.wrapping_mul(24).wrapping_add(17)).map(|x| x.wrapping_mul(25).wrapping_add(17)).map(|x| x.wrapping_mul(26).wrapping_add(17)).map(|x| x.wrapping_mul(27).wrapping_add(17)).map(|x| x.wrapping_mul(28).wrapping_add(17)).map(|x| x.wrapping_mul(29).wrapping_add(17)).map(|x| x.wrapping_mul(30).wrapping_add(17)).map(|x| x.wrapping_mul(31).wrapping_add(17)).map(|x| x.wrapping_mul(32).wrapping_add(17)).map(|x| x.wrapping_mul(33).wrapping_add(17)).map(|x| x.wrapping_mul(34).wrapping_add(17)).map(|x| x.wrapping_mul(35).wrapping_add(17)).map(|x| x.wrapping_mul(36).wrapping_add(17)).map(|x| x.wrapping_mul(37).wrapping_add(17)).map(|x| x.wrapping_mul(38).wrapping_add(17)).map(|x| x.wrapping_mul(39).wrapping_add(17)).map(|x| x.wrapping_mul(40).wrapping_add(17)).map(|x| x.wrapping_mul(41).wrapping_add(17)).map(|x| x.wrapping_mul(42).wrapping_add(17)).fold(0, u64::wrapping_add) } +pub fn busy_18() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(18)).map(|x| x.wrapping_mul(4).wrapping_add(18)).map(|x| x.wrapping_mul(5).wrapping_add(18)).map(|x| x.wrapping_mul(6).wrapping_add(18)).map(|x| x.wrapping_mul(7).wrapping_add(18)).map(|x| x.wrapping_mul(8).wrapping_add(18)).map(|x| x.wrapping_mul(9).wrapping_add(18)).map(|x| x.wrapping_mul(10).wrapping_add(18)).map(|x| x.wrapping_mul(11).wrapping_add(18)).map(|x| x.wrapping_mul(12).wrapping_add(18)).map(|x| x.wrapping_mul(13).wrapping_add(18)).map(|x| x.wrapping_mul(14).wrapping_add(18)).map(|x| x.wrapping_mul(15).wrapping_add(18)).map(|x| x.wrapping_mul(16).wrapping_add(18)).map(|x| x.wrapping_mul(17).wrapping_add(18)).map(|x| x.wrapping_mul(18).wrapping_add(18)).map(|x| x.wrapping_mul(19).wrapping_add(18)).map(|x| x.wrapping_mul(20).wrapping_add(18)).map(|x| x.wrapping_mul(21).wrapping_add(18)).map(|x| x.wrapping_mul(22).wrapping_add(18)).map(|x| x.wrapping_mul(23).wrapping_add(18)).map(|x| x.wrapping_mul(24).wrapping_add(18)).map(|x| x.wrapping_mul(25).wrapping_add(18)).map(|x| x.wrapping_mul(26).wrapping_add(18)).map(|x| x.wrapping_mul(27).wrapping_add(18)).map(|x| x.wrapping_mul(28).wrapping_add(18)).map(|x| x.wrapping_mul(29).wrapping_add(18)).map(|x| x.wrapping_mul(30).wrapping_add(18)).map(|x| x.wrapping_mul(31).wrapping_add(18)).map(|x| x.wrapping_mul(32).wrapping_add(18)).map(|x| x.wrapping_mul(33).wrapping_add(18)).map(|x| x.wrapping_mul(34).wrapping_add(18)).map(|x| x.wrapping_mul(35).wrapping_add(18)).map(|x| x.wrapping_mul(36).wrapping_add(18)).map(|x| x.wrapping_mul(37).wrapping_add(18)).map(|x| x.wrapping_mul(38).wrapping_add(18)).map(|x| x.wrapping_mul(39).wrapping_add(18)).map(|x| x.wrapping_mul(40).wrapping_add(18)).map(|x| x.wrapping_mul(41).wrapping_add(18)).map(|x| x.wrapping_mul(42).wrapping_add(18)).fold(0, u64::wrapping_add) } +pub fn busy_19() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(19)).map(|x| x.wrapping_mul(4).wrapping_add(19)).map(|x| x.wrapping_mul(5).wrapping_add(19)).map(|x| x.wrapping_mul(6).wrapping_add(19)).map(|x| x.wrapping_mul(7).wrapping_add(19)).map(|x| x.wrapping_mul(8).wrapping_add(19)).map(|x| x.wrapping_mul(9).wrapping_add(19)).map(|x| x.wrapping_mul(10).wrapping_add(19)).map(|x| x.wrapping_mul(11).wrapping_add(19)).map(|x| x.wrapping_mul(12).wrapping_add(19)).map(|x| x.wrapping_mul(13).wrapping_add(19)).map(|x| x.wrapping_mul(14).wrapping_add(19)).map(|x| x.wrapping_mul(15).wrapping_add(19)).map(|x| x.wrapping_mul(16).wrapping_add(19)).map(|x| x.wrapping_mul(17).wrapping_add(19)).map(|x| x.wrapping_mul(18).wrapping_add(19)).map(|x| x.wrapping_mul(19).wrapping_add(19)).map(|x| x.wrapping_mul(20).wrapping_add(19)).map(|x| x.wrapping_mul(21).wrapping_add(19)).map(|x| x.wrapping_mul(22).wrapping_add(19)).map(|x| x.wrapping_mul(23).wrapping_add(19)).map(|x| x.wrapping_mul(24).wrapping_add(19)).map(|x| x.wrapping_mul(25).wrapping_add(19)).map(|x| x.wrapping_mul(26).wrapping_add(19)).map(|x| x.wrapping_mul(27).wrapping_add(19)).map(|x| x.wrapping_mul(28).wrapping_add(19)).map(|x| x.wrapping_mul(29).wrapping_add(19)).map(|x| x.wrapping_mul(30).wrapping_add(19)).map(|x| x.wrapping_mul(31).wrapping_add(19)).map(|x| x.wrapping_mul(32).wrapping_add(19)).map(|x| x.wrapping_mul(33).wrapping_add(19)).map(|x| x.wrapping_mul(34).wrapping_add(19)).map(|x| x.wrapping_mul(35).wrapping_add(19)).map(|x| x.wrapping_mul(36).wrapping_add(19)).map(|x| x.wrapping_mul(37).wrapping_add(19)).map(|x| x.wrapping_mul(38).wrapping_add(19)).map(|x| x.wrapping_mul(39).wrapping_add(19)).map(|x| x.wrapping_mul(40).wrapping_add(19)).map(|x| x.wrapping_mul(41).wrapping_add(19)).map(|x| x.wrapping_mul(42).wrapping_add(19)).fold(0, u64::wrapping_add) } +pub fn busy_20() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(20)).map(|x| x.wrapping_mul(4).wrapping_add(20)).map(|x| x.wrapping_mul(5).wrapping_add(20)).map(|x| x.wrapping_mul(6).wrapping_add(20)).map(|x| x.wrapping_mul(7).wrapping_add(20)).map(|x| x.wrapping_mul(8).wrapping_add(20)).map(|x| x.wrapping_mul(9).wrapping_add(20)).map(|x| x.wrapping_mul(10).wrapping_add(20)).map(|x| x.wrapping_mul(11).wrapping_add(20)).map(|x| x.wrapping_mul(12).wrapping_add(20)).map(|x| x.wrapping_mul(13).wrapping_add(20)).map(|x| x.wrapping_mul(14).wrapping_add(20)).map(|x| x.wrapping_mul(15).wrapping_add(20)).map(|x| x.wrapping_mul(16).wrapping_add(20)).map(|x| x.wrapping_mul(17).wrapping_add(20)).map(|x| x.wrapping_mul(18).wrapping_add(20)).map(|x| x.wrapping_mul(19).wrapping_add(20)).map(|x| x.wrapping_mul(20).wrapping_add(20)).map(|x| x.wrapping_mul(21).wrapping_add(20)).map(|x| x.wrapping_mul(22).wrapping_add(20)).map(|x| x.wrapping_mul(23).wrapping_add(20)).map(|x| x.wrapping_mul(24).wrapping_add(20)).map(|x| x.wrapping_mul(25).wrapping_add(20)).map(|x| x.wrapping_mul(26).wrapping_add(20)).map(|x| x.wrapping_mul(27).wrapping_add(20)).map(|x| x.wrapping_mul(28).wrapping_add(20)).map(|x| x.wrapping_mul(29).wrapping_add(20)).map(|x| x.wrapping_mul(30).wrapping_add(20)).map(|x| x.wrapping_mul(31).wrapping_add(20)).map(|x| x.wrapping_mul(32).wrapping_add(20)).map(|x| x.wrapping_mul(33).wrapping_add(20)).map(|x| x.wrapping_mul(34).wrapping_add(20)).map(|x| x.wrapping_mul(35).wrapping_add(20)).map(|x| x.wrapping_mul(36).wrapping_add(20)).map(|x| x.wrapping_mul(37).wrapping_add(20)).map(|x| x.wrapping_mul(38).wrapping_add(20)).map(|x| x.wrapping_mul(39).wrapping_add(20)).map(|x| x.wrapping_mul(40).wrapping_add(20)).map(|x| x.wrapping_mul(41).wrapping_add(20)).map(|x| x.wrapping_mul(42).wrapping_add(20)).fold(0, u64::wrapping_add) } +pub fn busy_21() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(21)).map(|x| x.wrapping_mul(4).wrapping_add(21)).map(|x| x.wrapping_mul(5).wrapping_add(21)).map(|x| x.wrapping_mul(6).wrapping_add(21)).map(|x| x.wrapping_mul(7).wrapping_add(21)).map(|x| x.wrapping_mul(8).wrapping_add(21)).map(|x| x.wrapping_mul(9).wrapping_add(21)).map(|x| x.wrapping_mul(10).wrapping_add(21)).map(|x| x.wrapping_mul(11).wrapping_add(21)).map(|x| x.wrapping_mul(12).wrapping_add(21)).map(|x| x.wrapping_mul(13).wrapping_add(21)).map(|x| x.wrapping_mul(14).wrapping_add(21)).map(|x| x.wrapping_mul(15).wrapping_add(21)).map(|x| x.wrapping_mul(16).wrapping_add(21)).map(|x| x.wrapping_mul(17).wrapping_add(21)).map(|x| x.wrapping_mul(18).wrapping_add(21)).map(|x| x.wrapping_mul(19).wrapping_add(21)).map(|x| x.wrapping_mul(20).wrapping_add(21)).map(|x| x.wrapping_mul(21).wrapping_add(21)).map(|x| x.wrapping_mul(22).wrapping_add(21)).map(|x| x.wrapping_mul(23).wrapping_add(21)).map(|x| x.wrapping_mul(24).wrapping_add(21)).map(|x| x.wrapping_mul(25).wrapping_add(21)).map(|x| x.wrapping_mul(26).wrapping_add(21)).map(|x| x.wrapping_mul(27).wrapping_add(21)).map(|x| x.wrapping_mul(28).wrapping_add(21)).map(|x| x.wrapping_mul(29).wrapping_add(21)).map(|x| x.wrapping_mul(30).wrapping_add(21)).map(|x| x.wrapping_mul(31).wrapping_add(21)).map(|x| x.wrapping_mul(32).wrapping_add(21)).map(|x| x.wrapping_mul(33).wrapping_add(21)).map(|x| x.wrapping_mul(34).wrapping_add(21)).map(|x| x.wrapping_mul(35).wrapping_add(21)).map(|x| x.wrapping_mul(36).wrapping_add(21)).map(|x| x.wrapping_mul(37).wrapping_add(21)).map(|x| x.wrapping_mul(38).wrapping_add(21)).map(|x| x.wrapping_mul(39).wrapping_add(21)).map(|x| x.wrapping_mul(40).wrapping_add(21)).map(|x| x.wrapping_mul(41).wrapping_add(21)).map(|x| x.wrapping_mul(42).wrapping_add(21)).fold(0, u64::wrapping_add) } +pub fn busy_22() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(22)).map(|x| x.wrapping_mul(4).wrapping_add(22)).map(|x| x.wrapping_mul(5).wrapping_add(22)).map(|x| x.wrapping_mul(6).wrapping_add(22)).map(|x| x.wrapping_mul(7).wrapping_add(22)).map(|x| x.wrapping_mul(8).wrapping_add(22)).map(|x| x.wrapping_mul(9).wrapping_add(22)).map(|x| x.wrapping_mul(10).wrapping_add(22)).map(|x| x.wrapping_mul(11).wrapping_add(22)).map(|x| x.wrapping_mul(12).wrapping_add(22)).map(|x| x.wrapping_mul(13).wrapping_add(22)).map(|x| x.wrapping_mul(14).wrapping_add(22)).map(|x| x.wrapping_mul(15).wrapping_add(22)).map(|x| x.wrapping_mul(16).wrapping_add(22)).map(|x| x.wrapping_mul(17).wrapping_add(22)).map(|x| x.wrapping_mul(18).wrapping_add(22)).map(|x| x.wrapping_mul(19).wrapping_add(22)).map(|x| x.wrapping_mul(20).wrapping_add(22)).map(|x| x.wrapping_mul(21).wrapping_add(22)).map(|x| x.wrapping_mul(22).wrapping_add(22)).map(|x| x.wrapping_mul(23).wrapping_add(22)).map(|x| x.wrapping_mul(24).wrapping_add(22)).map(|x| x.wrapping_mul(25).wrapping_add(22)).map(|x| x.wrapping_mul(26).wrapping_add(22)).map(|x| x.wrapping_mul(27).wrapping_add(22)).map(|x| x.wrapping_mul(28).wrapping_add(22)).map(|x| x.wrapping_mul(29).wrapping_add(22)).map(|x| x.wrapping_mul(30).wrapping_add(22)).map(|x| x.wrapping_mul(31).wrapping_add(22)).map(|x| x.wrapping_mul(32).wrapping_add(22)).map(|x| x.wrapping_mul(33).wrapping_add(22)).map(|x| x.wrapping_mul(34).wrapping_add(22)).map(|x| x.wrapping_mul(35).wrapping_add(22)).map(|x| x.wrapping_mul(36).wrapping_add(22)).map(|x| x.wrapping_mul(37).wrapping_add(22)).map(|x| x.wrapping_mul(38).wrapping_add(22)).map(|x| x.wrapping_mul(39).wrapping_add(22)).map(|x| x.wrapping_mul(40).wrapping_add(22)).map(|x| x.wrapping_mul(41).wrapping_add(22)).map(|x| x.wrapping_mul(42).wrapping_add(22)).fold(0, u64::wrapping_add) } +pub fn busy_23() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(23)).map(|x| x.wrapping_mul(4).wrapping_add(23)).map(|x| x.wrapping_mul(5).wrapping_add(23)).map(|x| x.wrapping_mul(6).wrapping_add(23)).map(|x| x.wrapping_mul(7).wrapping_add(23)).map(|x| x.wrapping_mul(8).wrapping_add(23)).map(|x| x.wrapping_mul(9).wrapping_add(23)).map(|x| x.wrapping_mul(10).wrapping_add(23)).map(|x| x.wrapping_mul(11).wrapping_add(23)).map(|x| x.wrapping_mul(12).wrapping_add(23)).map(|x| x.wrapping_mul(13).wrapping_add(23)).map(|x| x.wrapping_mul(14).wrapping_add(23)).map(|x| x.wrapping_mul(15).wrapping_add(23)).map(|x| x.wrapping_mul(16).wrapping_add(23)).map(|x| x.wrapping_mul(17).wrapping_add(23)).map(|x| x.wrapping_mul(18).wrapping_add(23)).map(|x| x.wrapping_mul(19).wrapping_add(23)).map(|x| x.wrapping_mul(20).wrapping_add(23)).map(|x| x.wrapping_mul(21).wrapping_add(23)).map(|x| x.wrapping_mul(22).wrapping_add(23)).map(|x| x.wrapping_mul(23).wrapping_add(23)).map(|x| x.wrapping_mul(24).wrapping_add(23)).map(|x| x.wrapping_mul(25).wrapping_add(23)).map(|x| x.wrapping_mul(26).wrapping_add(23)).map(|x| x.wrapping_mul(27).wrapping_add(23)).map(|x| x.wrapping_mul(28).wrapping_add(23)).map(|x| x.wrapping_mul(29).wrapping_add(23)).map(|x| x.wrapping_mul(30).wrapping_add(23)).map(|x| x.wrapping_mul(31).wrapping_add(23)).map(|x| x.wrapping_mul(32).wrapping_add(23)).map(|x| x.wrapping_mul(33).wrapping_add(23)).map(|x| x.wrapping_mul(34).wrapping_add(23)).map(|x| x.wrapping_mul(35).wrapping_add(23)).map(|x| x.wrapping_mul(36).wrapping_add(23)).map(|x| x.wrapping_mul(37).wrapping_add(23)).map(|x| x.wrapping_mul(38).wrapping_add(23)).map(|x| x.wrapping_mul(39).wrapping_add(23)).map(|x| x.wrapping_mul(40).wrapping_add(23)).map(|x| x.wrapping_mul(41).wrapping_add(23)).map(|x| x.wrapping_mul(42).wrapping_add(23)).fold(0, u64::wrapping_add) } +pub fn busy_24() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(24)).map(|x| x.wrapping_mul(4).wrapping_add(24)).map(|x| x.wrapping_mul(5).wrapping_add(24)).map(|x| x.wrapping_mul(6).wrapping_add(24)).map(|x| x.wrapping_mul(7).wrapping_add(24)).map(|x| x.wrapping_mul(8).wrapping_add(24)).map(|x| x.wrapping_mul(9).wrapping_add(24)).map(|x| x.wrapping_mul(10).wrapping_add(24)).map(|x| x.wrapping_mul(11).wrapping_add(24)).map(|x| x.wrapping_mul(12).wrapping_add(24)).map(|x| x.wrapping_mul(13).wrapping_add(24)).map(|x| x.wrapping_mul(14).wrapping_add(24)).map(|x| x.wrapping_mul(15).wrapping_add(24)).map(|x| x.wrapping_mul(16).wrapping_add(24)).map(|x| x.wrapping_mul(17).wrapping_add(24)).map(|x| x.wrapping_mul(18).wrapping_add(24)).map(|x| x.wrapping_mul(19).wrapping_add(24)).map(|x| x.wrapping_mul(20).wrapping_add(24)).map(|x| x.wrapping_mul(21).wrapping_add(24)).map(|x| x.wrapping_mul(22).wrapping_add(24)).map(|x| x.wrapping_mul(23).wrapping_add(24)).map(|x| x.wrapping_mul(24).wrapping_add(24)).map(|x| x.wrapping_mul(25).wrapping_add(24)).map(|x| x.wrapping_mul(26).wrapping_add(24)).map(|x| x.wrapping_mul(27).wrapping_add(24)).map(|x| x.wrapping_mul(28).wrapping_add(24)).map(|x| x.wrapping_mul(29).wrapping_add(24)).map(|x| x.wrapping_mul(30).wrapping_add(24)).map(|x| x.wrapping_mul(31).wrapping_add(24)).map(|x| x.wrapping_mul(32).wrapping_add(24)).map(|x| x.wrapping_mul(33).wrapping_add(24)).map(|x| x.wrapping_mul(34).wrapping_add(24)).map(|x| x.wrapping_mul(35).wrapping_add(24)).map(|x| x.wrapping_mul(36).wrapping_add(24)).map(|x| x.wrapping_mul(37).wrapping_add(24)).map(|x| x.wrapping_mul(38).wrapping_add(24)).map(|x| x.wrapping_mul(39).wrapping_add(24)).map(|x| x.wrapping_mul(40).wrapping_add(24)).map(|x| x.wrapping_mul(41).wrapping_add(24)).map(|x| x.wrapping_mul(42).wrapping_add(24)).fold(0, u64::wrapping_add) } +pub fn busy_25() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(25)).map(|x| x.wrapping_mul(4).wrapping_add(25)).map(|x| x.wrapping_mul(5).wrapping_add(25)).map(|x| x.wrapping_mul(6).wrapping_add(25)).map(|x| x.wrapping_mul(7).wrapping_add(25)).map(|x| x.wrapping_mul(8).wrapping_add(25)).map(|x| x.wrapping_mul(9).wrapping_add(25)).map(|x| x.wrapping_mul(10).wrapping_add(25)).map(|x| x.wrapping_mul(11).wrapping_add(25)).map(|x| x.wrapping_mul(12).wrapping_add(25)).map(|x| x.wrapping_mul(13).wrapping_add(25)).map(|x| x.wrapping_mul(14).wrapping_add(25)).map(|x| x.wrapping_mul(15).wrapping_add(25)).map(|x| x.wrapping_mul(16).wrapping_add(25)).map(|x| x.wrapping_mul(17).wrapping_add(25)).map(|x| x.wrapping_mul(18).wrapping_add(25)).map(|x| x.wrapping_mul(19).wrapping_add(25)).map(|x| x.wrapping_mul(20).wrapping_add(25)).map(|x| x.wrapping_mul(21).wrapping_add(25)).map(|x| x.wrapping_mul(22).wrapping_add(25)).map(|x| x.wrapping_mul(23).wrapping_add(25)).map(|x| x.wrapping_mul(24).wrapping_add(25)).map(|x| x.wrapping_mul(25).wrapping_add(25)).map(|x| x.wrapping_mul(26).wrapping_add(25)).map(|x| x.wrapping_mul(27).wrapping_add(25)).map(|x| x.wrapping_mul(28).wrapping_add(25)).map(|x| x.wrapping_mul(29).wrapping_add(25)).map(|x| x.wrapping_mul(30).wrapping_add(25)).map(|x| x.wrapping_mul(31).wrapping_add(25)).map(|x| x.wrapping_mul(32).wrapping_add(25)).map(|x| x.wrapping_mul(33).wrapping_add(25)).map(|x| x.wrapping_mul(34).wrapping_add(25)).map(|x| x.wrapping_mul(35).wrapping_add(25)).map(|x| x.wrapping_mul(36).wrapping_add(25)).map(|x| x.wrapping_mul(37).wrapping_add(25)).map(|x| x.wrapping_mul(38).wrapping_add(25)).map(|x| x.wrapping_mul(39).wrapping_add(25)).map(|x| x.wrapping_mul(40).wrapping_add(25)).map(|x| x.wrapping_mul(41).wrapping_add(25)).map(|x| x.wrapping_mul(42).wrapping_add(25)).fold(0, u64::wrapping_add) } +pub fn busy_26() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(26)).map(|x| x.wrapping_mul(4).wrapping_add(26)).map(|x| x.wrapping_mul(5).wrapping_add(26)).map(|x| x.wrapping_mul(6).wrapping_add(26)).map(|x| x.wrapping_mul(7).wrapping_add(26)).map(|x| x.wrapping_mul(8).wrapping_add(26)).map(|x| x.wrapping_mul(9).wrapping_add(26)).map(|x| x.wrapping_mul(10).wrapping_add(26)).map(|x| x.wrapping_mul(11).wrapping_add(26)).map(|x| x.wrapping_mul(12).wrapping_add(26)).map(|x| x.wrapping_mul(13).wrapping_add(26)).map(|x| x.wrapping_mul(14).wrapping_add(26)).map(|x| x.wrapping_mul(15).wrapping_add(26)).map(|x| x.wrapping_mul(16).wrapping_add(26)).map(|x| x.wrapping_mul(17).wrapping_add(26)).map(|x| x.wrapping_mul(18).wrapping_add(26)).map(|x| x.wrapping_mul(19).wrapping_add(26)).map(|x| x.wrapping_mul(20).wrapping_add(26)).map(|x| x.wrapping_mul(21).wrapping_add(26)).map(|x| x.wrapping_mul(22).wrapping_add(26)).map(|x| x.wrapping_mul(23).wrapping_add(26)).map(|x| x.wrapping_mul(24).wrapping_add(26)).map(|x| x.wrapping_mul(25).wrapping_add(26)).map(|x| x.wrapping_mul(26).wrapping_add(26)).map(|x| x.wrapping_mul(27).wrapping_add(26)).map(|x| x.wrapping_mul(28).wrapping_add(26)).map(|x| x.wrapping_mul(29).wrapping_add(26)).map(|x| x.wrapping_mul(30).wrapping_add(26)).map(|x| x.wrapping_mul(31).wrapping_add(26)).map(|x| x.wrapping_mul(32).wrapping_add(26)).map(|x| x.wrapping_mul(33).wrapping_add(26)).map(|x| x.wrapping_mul(34).wrapping_add(26)).map(|x| x.wrapping_mul(35).wrapping_add(26)).map(|x| x.wrapping_mul(36).wrapping_add(26)).map(|x| x.wrapping_mul(37).wrapping_add(26)).map(|x| x.wrapping_mul(38).wrapping_add(26)).map(|x| x.wrapping_mul(39).wrapping_add(26)).map(|x| x.wrapping_mul(40).wrapping_add(26)).map(|x| x.wrapping_mul(41).wrapping_add(26)).map(|x| x.wrapping_mul(42).wrapping_add(26)).fold(0, u64::wrapping_add) } +pub fn busy_27() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(27)).map(|x| x.wrapping_mul(4).wrapping_add(27)).map(|x| x.wrapping_mul(5).wrapping_add(27)).map(|x| x.wrapping_mul(6).wrapping_add(27)).map(|x| x.wrapping_mul(7).wrapping_add(27)).map(|x| x.wrapping_mul(8).wrapping_add(27)).map(|x| x.wrapping_mul(9).wrapping_add(27)).map(|x| x.wrapping_mul(10).wrapping_add(27)).map(|x| x.wrapping_mul(11).wrapping_add(27)).map(|x| x.wrapping_mul(12).wrapping_add(27)).map(|x| x.wrapping_mul(13).wrapping_add(27)).map(|x| x.wrapping_mul(14).wrapping_add(27)).map(|x| x.wrapping_mul(15).wrapping_add(27)).map(|x| x.wrapping_mul(16).wrapping_add(27)).map(|x| x.wrapping_mul(17).wrapping_add(27)).map(|x| x.wrapping_mul(18).wrapping_add(27)).map(|x| x.wrapping_mul(19).wrapping_add(27)).map(|x| x.wrapping_mul(20).wrapping_add(27)).map(|x| x.wrapping_mul(21).wrapping_add(27)).map(|x| x.wrapping_mul(22).wrapping_add(27)).map(|x| x.wrapping_mul(23).wrapping_add(27)).map(|x| x.wrapping_mul(24).wrapping_add(27)).map(|x| x.wrapping_mul(25).wrapping_add(27)).map(|x| x.wrapping_mul(26).wrapping_add(27)).map(|x| x.wrapping_mul(27).wrapping_add(27)).map(|x| x.wrapping_mul(28).wrapping_add(27)).map(|x| x.wrapping_mul(29).wrapping_add(27)).map(|x| x.wrapping_mul(30).wrapping_add(27)).map(|x| x.wrapping_mul(31).wrapping_add(27)).map(|x| x.wrapping_mul(32).wrapping_add(27)).map(|x| x.wrapping_mul(33).wrapping_add(27)).map(|x| x.wrapping_mul(34).wrapping_add(27)).map(|x| x.wrapping_mul(35).wrapping_add(27)).map(|x| x.wrapping_mul(36).wrapping_add(27)).map(|x| x.wrapping_mul(37).wrapping_add(27)).map(|x| x.wrapping_mul(38).wrapping_add(27)).map(|x| x.wrapping_mul(39).wrapping_add(27)).map(|x| x.wrapping_mul(40).wrapping_add(27)).map(|x| x.wrapping_mul(41).wrapping_add(27)).map(|x| x.wrapping_mul(42).wrapping_add(27)).fold(0, u64::wrapping_add) } +pub fn busy_28() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(28)).map(|x| x.wrapping_mul(4).wrapping_add(28)).map(|x| x.wrapping_mul(5).wrapping_add(28)).map(|x| x.wrapping_mul(6).wrapping_add(28)).map(|x| x.wrapping_mul(7).wrapping_add(28)).map(|x| x.wrapping_mul(8).wrapping_add(28)).map(|x| x.wrapping_mul(9).wrapping_add(28)).map(|x| x.wrapping_mul(10).wrapping_add(28)).map(|x| x.wrapping_mul(11).wrapping_add(28)).map(|x| x.wrapping_mul(12).wrapping_add(28)).map(|x| x.wrapping_mul(13).wrapping_add(28)).map(|x| x.wrapping_mul(14).wrapping_add(28)).map(|x| x.wrapping_mul(15).wrapping_add(28)).map(|x| x.wrapping_mul(16).wrapping_add(28)).map(|x| x.wrapping_mul(17).wrapping_add(28)).map(|x| x.wrapping_mul(18).wrapping_add(28)).map(|x| x.wrapping_mul(19).wrapping_add(28)).map(|x| x.wrapping_mul(20).wrapping_add(28)).map(|x| x.wrapping_mul(21).wrapping_add(28)).map(|x| x.wrapping_mul(22).wrapping_add(28)).map(|x| x.wrapping_mul(23).wrapping_add(28)).map(|x| x.wrapping_mul(24).wrapping_add(28)).map(|x| x.wrapping_mul(25).wrapping_add(28)).map(|x| x.wrapping_mul(26).wrapping_add(28)).map(|x| x.wrapping_mul(27).wrapping_add(28)).map(|x| x.wrapping_mul(28).wrapping_add(28)).map(|x| x.wrapping_mul(29).wrapping_add(28)).map(|x| x.wrapping_mul(30).wrapping_add(28)).map(|x| x.wrapping_mul(31).wrapping_add(28)).map(|x| x.wrapping_mul(32).wrapping_add(28)).map(|x| x.wrapping_mul(33).wrapping_add(28)).map(|x| x.wrapping_mul(34).wrapping_add(28)).map(|x| x.wrapping_mul(35).wrapping_add(28)).map(|x| x.wrapping_mul(36).wrapping_add(28)).map(|x| x.wrapping_mul(37).wrapping_add(28)).map(|x| x.wrapping_mul(38).wrapping_add(28)).map(|x| x.wrapping_mul(39).wrapping_add(28)).map(|x| x.wrapping_mul(40).wrapping_add(28)).map(|x| x.wrapping_mul(41).wrapping_add(28)).map(|x| x.wrapping_mul(42).wrapping_add(28)).fold(0, u64::wrapping_add) } +pub fn busy_29() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(29)).map(|x| x.wrapping_mul(4).wrapping_add(29)).map(|x| x.wrapping_mul(5).wrapping_add(29)).map(|x| x.wrapping_mul(6).wrapping_add(29)).map(|x| x.wrapping_mul(7).wrapping_add(29)).map(|x| x.wrapping_mul(8).wrapping_add(29)).map(|x| x.wrapping_mul(9).wrapping_add(29)).map(|x| x.wrapping_mul(10).wrapping_add(29)).map(|x| x.wrapping_mul(11).wrapping_add(29)).map(|x| x.wrapping_mul(12).wrapping_add(29)).map(|x| x.wrapping_mul(13).wrapping_add(29)).map(|x| x.wrapping_mul(14).wrapping_add(29)).map(|x| x.wrapping_mul(15).wrapping_add(29)).map(|x| x.wrapping_mul(16).wrapping_add(29)).map(|x| x.wrapping_mul(17).wrapping_add(29)).map(|x| x.wrapping_mul(18).wrapping_add(29)).map(|x| x.wrapping_mul(19).wrapping_add(29)).map(|x| x.wrapping_mul(20).wrapping_add(29)).map(|x| x.wrapping_mul(21).wrapping_add(29)).map(|x| x.wrapping_mul(22).wrapping_add(29)).map(|x| x.wrapping_mul(23).wrapping_add(29)).map(|x| x.wrapping_mul(24).wrapping_add(29)).map(|x| x.wrapping_mul(25).wrapping_add(29)).map(|x| x.wrapping_mul(26).wrapping_add(29)).map(|x| x.wrapping_mul(27).wrapping_add(29)).map(|x| x.wrapping_mul(28).wrapping_add(29)).map(|x| x.wrapping_mul(29).wrapping_add(29)).map(|x| x.wrapping_mul(30).wrapping_add(29)).map(|x| x.wrapping_mul(31).wrapping_add(29)).map(|x| x.wrapping_mul(32).wrapping_add(29)).map(|x| x.wrapping_mul(33).wrapping_add(29)).map(|x| x.wrapping_mul(34).wrapping_add(29)).map(|x| x.wrapping_mul(35).wrapping_add(29)).map(|x| x.wrapping_mul(36).wrapping_add(29)).map(|x| x.wrapping_mul(37).wrapping_add(29)).map(|x| x.wrapping_mul(38).wrapping_add(29)).map(|x| x.wrapping_mul(39).wrapping_add(29)).map(|x| x.wrapping_mul(40).wrapping_add(29)).map(|x| x.wrapping_mul(41).wrapping_add(29)).map(|x| x.wrapping_mul(42).wrapping_add(29)).fold(0, u64::wrapping_add) } +pub fn busy_30() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(30)).map(|x| x.wrapping_mul(4).wrapping_add(30)).map(|x| x.wrapping_mul(5).wrapping_add(30)).map(|x| x.wrapping_mul(6).wrapping_add(30)).map(|x| x.wrapping_mul(7).wrapping_add(30)).map(|x| x.wrapping_mul(8).wrapping_add(30)).map(|x| x.wrapping_mul(9).wrapping_add(30)).map(|x| x.wrapping_mul(10).wrapping_add(30)).map(|x| x.wrapping_mul(11).wrapping_add(30)).map(|x| x.wrapping_mul(12).wrapping_add(30)).map(|x| x.wrapping_mul(13).wrapping_add(30)).map(|x| x.wrapping_mul(14).wrapping_add(30)).map(|x| x.wrapping_mul(15).wrapping_add(30)).map(|x| x.wrapping_mul(16).wrapping_add(30)).map(|x| x.wrapping_mul(17).wrapping_add(30)).map(|x| x.wrapping_mul(18).wrapping_add(30)).map(|x| x.wrapping_mul(19).wrapping_add(30)).map(|x| x.wrapping_mul(20).wrapping_add(30)).map(|x| x.wrapping_mul(21).wrapping_add(30)).map(|x| x.wrapping_mul(22).wrapping_add(30)).map(|x| x.wrapping_mul(23).wrapping_add(30)).map(|x| x.wrapping_mul(24).wrapping_add(30)).map(|x| x.wrapping_mul(25).wrapping_add(30)).map(|x| x.wrapping_mul(26).wrapping_add(30)).map(|x| x.wrapping_mul(27).wrapping_add(30)).map(|x| x.wrapping_mul(28).wrapping_add(30)).map(|x| x.wrapping_mul(29).wrapping_add(30)).map(|x| x.wrapping_mul(30).wrapping_add(30)).map(|x| x.wrapping_mul(31).wrapping_add(30)).map(|x| x.wrapping_mul(32).wrapping_add(30)).map(|x| x.wrapping_mul(33).wrapping_add(30)).map(|x| x.wrapping_mul(34).wrapping_add(30)).map(|x| x.wrapping_mul(35).wrapping_add(30)).map(|x| x.wrapping_mul(36).wrapping_add(30)).map(|x| x.wrapping_mul(37).wrapping_add(30)).map(|x| x.wrapping_mul(38).wrapping_add(30)).map(|x| x.wrapping_mul(39).wrapping_add(30)).map(|x| x.wrapping_mul(40).wrapping_add(30)).map(|x| x.wrapping_mul(41).wrapping_add(30)).map(|x| x.wrapping_mul(42).wrapping_add(30)).fold(0, u64::wrapping_add) } +pub fn busy_31() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(31)).map(|x| x.wrapping_mul(4).wrapping_add(31)).map(|x| x.wrapping_mul(5).wrapping_add(31)).map(|x| x.wrapping_mul(6).wrapping_add(31)).map(|x| x.wrapping_mul(7).wrapping_add(31)).map(|x| x.wrapping_mul(8).wrapping_add(31)).map(|x| x.wrapping_mul(9).wrapping_add(31)).map(|x| x.wrapping_mul(10).wrapping_add(31)).map(|x| x.wrapping_mul(11).wrapping_add(31)).map(|x| x.wrapping_mul(12).wrapping_add(31)).map(|x| x.wrapping_mul(13).wrapping_add(31)).map(|x| x.wrapping_mul(14).wrapping_add(31)).map(|x| x.wrapping_mul(15).wrapping_add(31)).map(|x| x.wrapping_mul(16).wrapping_add(31)).map(|x| x.wrapping_mul(17).wrapping_add(31)).map(|x| x.wrapping_mul(18).wrapping_add(31)).map(|x| x.wrapping_mul(19).wrapping_add(31)).map(|x| x.wrapping_mul(20).wrapping_add(31)).map(|x| x.wrapping_mul(21).wrapping_add(31)).map(|x| x.wrapping_mul(22).wrapping_add(31)).map(|x| x.wrapping_mul(23).wrapping_add(31)).map(|x| x.wrapping_mul(24).wrapping_add(31)).map(|x| x.wrapping_mul(25).wrapping_add(31)).map(|x| x.wrapping_mul(26).wrapping_add(31)).map(|x| x.wrapping_mul(27).wrapping_add(31)).map(|x| x.wrapping_mul(28).wrapping_add(31)).map(|x| x.wrapping_mul(29).wrapping_add(31)).map(|x| x.wrapping_mul(30).wrapping_add(31)).map(|x| x.wrapping_mul(31).wrapping_add(31)).map(|x| x.wrapping_mul(32).wrapping_add(31)).map(|x| x.wrapping_mul(33).wrapping_add(31)).map(|x| x.wrapping_mul(34).wrapping_add(31)).map(|x| x.wrapping_mul(35).wrapping_add(31)).map(|x| x.wrapping_mul(36).wrapping_add(31)).map(|x| x.wrapping_mul(37).wrapping_add(31)).map(|x| x.wrapping_mul(38).wrapping_add(31)).map(|x| x.wrapping_mul(39).wrapping_add(31)).map(|x| x.wrapping_mul(40).wrapping_add(31)).map(|x| x.wrapping_mul(41).wrapping_add(31)).map(|x| x.wrapping_mul(42).wrapping_add(31)).fold(0, u64::wrapping_add) } +pub fn busy_32() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(32)).map(|x| x.wrapping_mul(4).wrapping_add(32)).map(|x| x.wrapping_mul(5).wrapping_add(32)).map(|x| x.wrapping_mul(6).wrapping_add(32)).map(|x| x.wrapping_mul(7).wrapping_add(32)).map(|x| x.wrapping_mul(8).wrapping_add(32)).map(|x| x.wrapping_mul(9).wrapping_add(32)).map(|x| x.wrapping_mul(10).wrapping_add(32)).map(|x| x.wrapping_mul(11).wrapping_add(32)).map(|x| x.wrapping_mul(12).wrapping_add(32)).map(|x| x.wrapping_mul(13).wrapping_add(32)).map(|x| x.wrapping_mul(14).wrapping_add(32)).map(|x| x.wrapping_mul(15).wrapping_add(32)).map(|x| x.wrapping_mul(16).wrapping_add(32)).map(|x| x.wrapping_mul(17).wrapping_add(32)).map(|x| x.wrapping_mul(18).wrapping_add(32)).map(|x| x.wrapping_mul(19).wrapping_add(32)).map(|x| x.wrapping_mul(20).wrapping_add(32)).map(|x| x.wrapping_mul(21).wrapping_add(32)).map(|x| x.wrapping_mul(22).wrapping_add(32)).map(|x| x.wrapping_mul(23).wrapping_add(32)).map(|x| x.wrapping_mul(24).wrapping_add(32)).map(|x| x.wrapping_mul(25).wrapping_add(32)).map(|x| x.wrapping_mul(26).wrapping_add(32)).map(|x| x.wrapping_mul(27).wrapping_add(32)).map(|x| x.wrapping_mul(28).wrapping_add(32)).map(|x| x.wrapping_mul(29).wrapping_add(32)).map(|x| x.wrapping_mul(30).wrapping_add(32)).map(|x| x.wrapping_mul(31).wrapping_add(32)).map(|x| x.wrapping_mul(32).wrapping_add(32)).map(|x| x.wrapping_mul(33).wrapping_add(32)).map(|x| x.wrapping_mul(34).wrapping_add(32)).map(|x| x.wrapping_mul(35).wrapping_add(32)).map(|x| x.wrapping_mul(36).wrapping_add(32)).map(|x| x.wrapping_mul(37).wrapping_add(32)).map(|x| x.wrapping_mul(38).wrapping_add(32)).map(|x| x.wrapping_mul(39).wrapping_add(32)).map(|x| x.wrapping_mul(40).wrapping_add(32)).map(|x| x.wrapping_mul(41).wrapping_add(32)).map(|x| x.wrapping_mul(42).wrapping_add(32)).fold(0, u64::wrapping_add) } +pub fn busy_33() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(33)).map(|x| x.wrapping_mul(4).wrapping_add(33)).map(|x| x.wrapping_mul(5).wrapping_add(33)).map(|x| x.wrapping_mul(6).wrapping_add(33)).map(|x| x.wrapping_mul(7).wrapping_add(33)).map(|x| x.wrapping_mul(8).wrapping_add(33)).map(|x| x.wrapping_mul(9).wrapping_add(33)).map(|x| x.wrapping_mul(10).wrapping_add(33)).map(|x| x.wrapping_mul(11).wrapping_add(33)).map(|x| x.wrapping_mul(12).wrapping_add(33)).map(|x| x.wrapping_mul(13).wrapping_add(33)).map(|x| x.wrapping_mul(14).wrapping_add(33)).map(|x| x.wrapping_mul(15).wrapping_add(33)).map(|x| x.wrapping_mul(16).wrapping_add(33)).map(|x| x.wrapping_mul(17).wrapping_add(33)).map(|x| x.wrapping_mul(18).wrapping_add(33)).map(|x| x.wrapping_mul(19).wrapping_add(33)).map(|x| x.wrapping_mul(20).wrapping_add(33)).map(|x| x.wrapping_mul(21).wrapping_add(33)).map(|x| x.wrapping_mul(22).wrapping_add(33)).map(|x| x.wrapping_mul(23).wrapping_add(33)).map(|x| x.wrapping_mul(24).wrapping_add(33)).map(|x| x.wrapping_mul(25).wrapping_add(33)).map(|x| x.wrapping_mul(26).wrapping_add(33)).map(|x| x.wrapping_mul(27).wrapping_add(33)).map(|x| x.wrapping_mul(28).wrapping_add(33)).map(|x| x.wrapping_mul(29).wrapping_add(33)).map(|x| x.wrapping_mul(30).wrapping_add(33)).map(|x| x.wrapping_mul(31).wrapping_add(33)).map(|x| x.wrapping_mul(32).wrapping_add(33)).map(|x| x.wrapping_mul(33).wrapping_add(33)).map(|x| x.wrapping_mul(34).wrapping_add(33)).map(|x| x.wrapping_mul(35).wrapping_add(33)).map(|x| x.wrapping_mul(36).wrapping_add(33)).map(|x| x.wrapping_mul(37).wrapping_add(33)).map(|x| x.wrapping_mul(38).wrapping_add(33)).map(|x| x.wrapping_mul(39).wrapping_add(33)).map(|x| x.wrapping_mul(40).wrapping_add(33)).map(|x| x.wrapping_mul(41).wrapping_add(33)).map(|x| x.wrapping_mul(42).wrapping_add(33)).fold(0, u64::wrapping_add) } +pub fn busy_34() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(34)).map(|x| x.wrapping_mul(4).wrapping_add(34)).map(|x| x.wrapping_mul(5).wrapping_add(34)).map(|x| x.wrapping_mul(6).wrapping_add(34)).map(|x| x.wrapping_mul(7).wrapping_add(34)).map(|x| x.wrapping_mul(8).wrapping_add(34)).map(|x| x.wrapping_mul(9).wrapping_add(34)).map(|x| x.wrapping_mul(10).wrapping_add(34)).map(|x| x.wrapping_mul(11).wrapping_add(34)).map(|x| x.wrapping_mul(12).wrapping_add(34)).map(|x| x.wrapping_mul(13).wrapping_add(34)).map(|x| x.wrapping_mul(14).wrapping_add(34)).map(|x| x.wrapping_mul(15).wrapping_add(34)).map(|x| x.wrapping_mul(16).wrapping_add(34)).map(|x| x.wrapping_mul(17).wrapping_add(34)).map(|x| x.wrapping_mul(18).wrapping_add(34)).map(|x| x.wrapping_mul(19).wrapping_add(34)).map(|x| x.wrapping_mul(20).wrapping_add(34)).map(|x| x.wrapping_mul(21).wrapping_add(34)).map(|x| x.wrapping_mul(22).wrapping_add(34)).map(|x| x.wrapping_mul(23).wrapping_add(34)).map(|x| x.wrapping_mul(24).wrapping_add(34)).map(|x| x.wrapping_mul(25).wrapping_add(34)).map(|x| x.wrapping_mul(26).wrapping_add(34)).map(|x| x.wrapping_mul(27).wrapping_add(34)).map(|x| x.wrapping_mul(28).wrapping_add(34)).map(|x| x.wrapping_mul(29).wrapping_add(34)).map(|x| x.wrapping_mul(30).wrapping_add(34)).map(|x| x.wrapping_mul(31).wrapping_add(34)).map(|x| x.wrapping_mul(32).wrapping_add(34)).map(|x| x.wrapping_mul(33).wrapping_add(34)).map(|x| x.wrapping_mul(34).wrapping_add(34)).map(|x| x.wrapping_mul(35).wrapping_add(34)).map(|x| x.wrapping_mul(36).wrapping_add(34)).map(|x| x.wrapping_mul(37).wrapping_add(34)).map(|x| x.wrapping_mul(38).wrapping_add(34)).map(|x| x.wrapping_mul(39).wrapping_add(34)).map(|x| x.wrapping_mul(40).wrapping_add(34)).map(|x| x.wrapping_mul(41).wrapping_add(34)).map(|x| x.wrapping_mul(42).wrapping_add(34)).fold(0, u64::wrapping_add) } +pub fn busy_35() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(35)).map(|x| x.wrapping_mul(4).wrapping_add(35)).map(|x| x.wrapping_mul(5).wrapping_add(35)).map(|x| x.wrapping_mul(6).wrapping_add(35)).map(|x| x.wrapping_mul(7).wrapping_add(35)).map(|x| x.wrapping_mul(8).wrapping_add(35)).map(|x| x.wrapping_mul(9).wrapping_add(35)).map(|x| x.wrapping_mul(10).wrapping_add(35)).map(|x| x.wrapping_mul(11).wrapping_add(35)).map(|x| x.wrapping_mul(12).wrapping_add(35)).map(|x| x.wrapping_mul(13).wrapping_add(35)).map(|x| x.wrapping_mul(14).wrapping_add(35)).map(|x| x.wrapping_mul(15).wrapping_add(35)).map(|x| x.wrapping_mul(16).wrapping_add(35)).map(|x| x.wrapping_mul(17).wrapping_add(35)).map(|x| x.wrapping_mul(18).wrapping_add(35)).map(|x| x.wrapping_mul(19).wrapping_add(35)).map(|x| x.wrapping_mul(20).wrapping_add(35)).map(|x| x.wrapping_mul(21).wrapping_add(35)).map(|x| x.wrapping_mul(22).wrapping_add(35)).map(|x| x.wrapping_mul(23).wrapping_add(35)).map(|x| x.wrapping_mul(24).wrapping_add(35)).map(|x| x.wrapping_mul(25).wrapping_add(35)).map(|x| x.wrapping_mul(26).wrapping_add(35)).map(|x| x.wrapping_mul(27).wrapping_add(35)).map(|x| x.wrapping_mul(28).wrapping_add(35)).map(|x| x.wrapping_mul(29).wrapping_add(35)).map(|x| x.wrapping_mul(30).wrapping_add(35)).map(|x| x.wrapping_mul(31).wrapping_add(35)).map(|x| x.wrapping_mul(32).wrapping_add(35)).map(|x| x.wrapping_mul(33).wrapping_add(35)).map(|x| x.wrapping_mul(34).wrapping_add(35)).map(|x| x.wrapping_mul(35).wrapping_add(35)).map(|x| x.wrapping_mul(36).wrapping_add(35)).map(|x| x.wrapping_mul(37).wrapping_add(35)).map(|x| x.wrapping_mul(38).wrapping_add(35)).map(|x| x.wrapping_mul(39).wrapping_add(35)).map(|x| x.wrapping_mul(40).wrapping_add(35)).map(|x| x.wrapping_mul(41).wrapping_add(35)).map(|x| x.wrapping_mul(42).wrapping_add(35)).fold(0, u64::wrapping_add) } +pub fn busy_36() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(36)).map(|x| x.wrapping_mul(4).wrapping_add(36)).map(|x| x.wrapping_mul(5).wrapping_add(36)).map(|x| x.wrapping_mul(6).wrapping_add(36)).map(|x| x.wrapping_mul(7).wrapping_add(36)).map(|x| x.wrapping_mul(8).wrapping_add(36)).map(|x| x.wrapping_mul(9).wrapping_add(36)).map(|x| x.wrapping_mul(10).wrapping_add(36)).map(|x| x.wrapping_mul(11).wrapping_add(36)).map(|x| x.wrapping_mul(12).wrapping_add(36)).map(|x| x.wrapping_mul(13).wrapping_add(36)).map(|x| x.wrapping_mul(14).wrapping_add(36)).map(|x| x.wrapping_mul(15).wrapping_add(36)).map(|x| x.wrapping_mul(16).wrapping_add(36)).map(|x| x.wrapping_mul(17).wrapping_add(36)).map(|x| x.wrapping_mul(18).wrapping_add(36)).map(|x| x.wrapping_mul(19).wrapping_add(36)).map(|x| x.wrapping_mul(20).wrapping_add(36)).map(|x| x.wrapping_mul(21).wrapping_add(36)).map(|x| x.wrapping_mul(22).wrapping_add(36)).map(|x| x.wrapping_mul(23).wrapping_add(36)).map(|x| x.wrapping_mul(24).wrapping_add(36)).map(|x| x.wrapping_mul(25).wrapping_add(36)).map(|x| x.wrapping_mul(26).wrapping_add(36)).map(|x| x.wrapping_mul(27).wrapping_add(36)).map(|x| x.wrapping_mul(28).wrapping_add(36)).map(|x| x.wrapping_mul(29).wrapping_add(36)).map(|x| x.wrapping_mul(30).wrapping_add(36)).map(|x| x.wrapping_mul(31).wrapping_add(36)).map(|x| x.wrapping_mul(32).wrapping_add(36)).map(|x| x.wrapping_mul(33).wrapping_add(36)).map(|x| x.wrapping_mul(34).wrapping_add(36)).map(|x| x.wrapping_mul(35).wrapping_add(36)).map(|x| x.wrapping_mul(36).wrapping_add(36)).map(|x| x.wrapping_mul(37).wrapping_add(36)).map(|x| x.wrapping_mul(38).wrapping_add(36)).map(|x| x.wrapping_mul(39).wrapping_add(36)).map(|x| x.wrapping_mul(40).wrapping_add(36)).map(|x| x.wrapping_mul(41).wrapping_add(36)).map(|x| x.wrapping_mul(42).wrapping_add(36)).fold(0, u64::wrapping_add) } +pub fn busy_37() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(37)).map(|x| x.wrapping_mul(4).wrapping_add(37)).map(|x| x.wrapping_mul(5).wrapping_add(37)).map(|x| x.wrapping_mul(6).wrapping_add(37)).map(|x| x.wrapping_mul(7).wrapping_add(37)).map(|x| x.wrapping_mul(8).wrapping_add(37)).map(|x| x.wrapping_mul(9).wrapping_add(37)).map(|x| x.wrapping_mul(10).wrapping_add(37)).map(|x| x.wrapping_mul(11).wrapping_add(37)).map(|x| x.wrapping_mul(12).wrapping_add(37)).map(|x| x.wrapping_mul(13).wrapping_add(37)).map(|x| x.wrapping_mul(14).wrapping_add(37)).map(|x| x.wrapping_mul(15).wrapping_add(37)).map(|x| x.wrapping_mul(16).wrapping_add(37)).map(|x| x.wrapping_mul(17).wrapping_add(37)).map(|x| x.wrapping_mul(18).wrapping_add(37)).map(|x| x.wrapping_mul(19).wrapping_add(37)).map(|x| x.wrapping_mul(20).wrapping_add(37)).map(|x| x.wrapping_mul(21).wrapping_add(37)).map(|x| x.wrapping_mul(22).wrapping_add(37)).map(|x| x.wrapping_mul(23).wrapping_add(37)).map(|x| x.wrapping_mul(24).wrapping_add(37)).map(|x| x.wrapping_mul(25).wrapping_add(37)).map(|x| x.wrapping_mul(26).wrapping_add(37)).map(|x| x.wrapping_mul(27).wrapping_add(37)).map(|x| x.wrapping_mul(28).wrapping_add(37)).map(|x| x.wrapping_mul(29).wrapping_add(37)).map(|x| x.wrapping_mul(30).wrapping_add(37)).map(|x| x.wrapping_mul(31).wrapping_add(37)).map(|x| x.wrapping_mul(32).wrapping_add(37)).map(|x| x.wrapping_mul(33).wrapping_add(37)).map(|x| x.wrapping_mul(34).wrapping_add(37)).map(|x| x.wrapping_mul(35).wrapping_add(37)).map(|x| x.wrapping_mul(36).wrapping_add(37)).map(|x| x.wrapping_mul(37).wrapping_add(37)).map(|x| x.wrapping_mul(38).wrapping_add(37)).map(|x| x.wrapping_mul(39).wrapping_add(37)).map(|x| x.wrapping_mul(40).wrapping_add(37)).map(|x| x.wrapping_mul(41).wrapping_add(37)).map(|x| x.wrapping_mul(42).wrapping_add(37)).fold(0, u64::wrapping_add) } +pub fn busy_38() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(38)).map(|x| x.wrapping_mul(4).wrapping_add(38)).map(|x| x.wrapping_mul(5).wrapping_add(38)).map(|x| x.wrapping_mul(6).wrapping_add(38)).map(|x| x.wrapping_mul(7).wrapping_add(38)).map(|x| x.wrapping_mul(8).wrapping_add(38)).map(|x| x.wrapping_mul(9).wrapping_add(38)).map(|x| x.wrapping_mul(10).wrapping_add(38)).map(|x| x.wrapping_mul(11).wrapping_add(38)).map(|x| x.wrapping_mul(12).wrapping_add(38)).map(|x| x.wrapping_mul(13).wrapping_add(38)).map(|x| x.wrapping_mul(14).wrapping_add(38)).map(|x| x.wrapping_mul(15).wrapping_add(38)).map(|x| x.wrapping_mul(16).wrapping_add(38)).map(|x| x.wrapping_mul(17).wrapping_add(38)).map(|x| x.wrapping_mul(18).wrapping_add(38)).map(|x| x.wrapping_mul(19).wrapping_add(38)).map(|x| x.wrapping_mul(20).wrapping_add(38)).map(|x| x.wrapping_mul(21).wrapping_add(38)).map(|x| x.wrapping_mul(22).wrapping_add(38)).map(|x| x.wrapping_mul(23).wrapping_add(38)).map(|x| x.wrapping_mul(24).wrapping_add(38)).map(|x| x.wrapping_mul(25).wrapping_add(38)).map(|x| x.wrapping_mul(26).wrapping_add(38)).map(|x| x.wrapping_mul(27).wrapping_add(38)).map(|x| x.wrapping_mul(28).wrapping_add(38)).map(|x| x.wrapping_mul(29).wrapping_add(38)).map(|x| x.wrapping_mul(30).wrapping_add(38)).map(|x| x.wrapping_mul(31).wrapping_add(38)).map(|x| x.wrapping_mul(32).wrapping_add(38)).map(|x| x.wrapping_mul(33).wrapping_add(38)).map(|x| x.wrapping_mul(34).wrapping_add(38)).map(|x| x.wrapping_mul(35).wrapping_add(38)).map(|x| x.wrapping_mul(36).wrapping_add(38)).map(|x| x.wrapping_mul(37).wrapping_add(38)).map(|x| x.wrapping_mul(38).wrapping_add(38)).map(|x| x.wrapping_mul(39).wrapping_add(38)).map(|x| x.wrapping_mul(40).wrapping_add(38)).map(|x| x.wrapping_mul(41).wrapping_add(38)).map(|x| x.wrapping_mul(42).wrapping_add(38)).fold(0, u64::wrapping_add) } +pub fn busy_39() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(39)).map(|x| x.wrapping_mul(4).wrapping_add(39)).map(|x| x.wrapping_mul(5).wrapping_add(39)).map(|x| x.wrapping_mul(6).wrapping_add(39)).map(|x| x.wrapping_mul(7).wrapping_add(39)).map(|x| x.wrapping_mul(8).wrapping_add(39)).map(|x| x.wrapping_mul(9).wrapping_add(39)).map(|x| x.wrapping_mul(10).wrapping_add(39)).map(|x| x.wrapping_mul(11).wrapping_add(39)).map(|x| x.wrapping_mul(12).wrapping_add(39)).map(|x| x.wrapping_mul(13).wrapping_add(39)).map(|x| x.wrapping_mul(14).wrapping_add(39)).map(|x| x.wrapping_mul(15).wrapping_add(39)).map(|x| x.wrapping_mul(16).wrapping_add(39)).map(|x| x.wrapping_mul(17).wrapping_add(39)).map(|x| x.wrapping_mul(18).wrapping_add(39)).map(|x| x.wrapping_mul(19).wrapping_add(39)).map(|x| x.wrapping_mul(20).wrapping_add(39)).map(|x| x.wrapping_mul(21).wrapping_add(39)).map(|x| x.wrapping_mul(22).wrapping_add(39)).map(|x| x.wrapping_mul(23).wrapping_add(39)).map(|x| x.wrapping_mul(24).wrapping_add(39)).map(|x| x.wrapping_mul(25).wrapping_add(39)).map(|x| x.wrapping_mul(26).wrapping_add(39)).map(|x| x.wrapping_mul(27).wrapping_add(39)).map(|x| x.wrapping_mul(28).wrapping_add(39)).map(|x| x.wrapping_mul(29).wrapping_add(39)).map(|x| x.wrapping_mul(30).wrapping_add(39)).map(|x| x.wrapping_mul(31).wrapping_add(39)).map(|x| x.wrapping_mul(32).wrapping_add(39)).map(|x| x.wrapping_mul(33).wrapping_add(39)).map(|x| x.wrapping_mul(34).wrapping_add(39)).map(|x| x.wrapping_mul(35).wrapping_add(39)).map(|x| x.wrapping_mul(36).wrapping_add(39)).map(|x| x.wrapping_mul(37).wrapping_add(39)).map(|x| x.wrapping_mul(38).wrapping_add(39)).map(|x| x.wrapping_mul(39).wrapping_add(39)).map(|x| x.wrapping_mul(40).wrapping_add(39)).map(|x| x.wrapping_mul(41).wrapping_add(39)).map(|x| x.wrapping_mul(42).wrapping_add(39)).fold(0, u64::wrapping_add) } +pub fn busy_40() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(40)).map(|x| x.wrapping_mul(4).wrapping_add(40)).map(|x| x.wrapping_mul(5).wrapping_add(40)).map(|x| x.wrapping_mul(6).wrapping_add(40)).map(|x| x.wrapping_mul(7).wrapping_add(40)).map(|x| x.wrapping_mul(8).wrapping_add(40)).map(|x| x.wrapping_mul(9).wrapping_add(40)).map(|x| x.wrapping_mul(10).wrapping_add(40)).map(|x| x.wrapping_mul(11).wrapping_add(40)).map(|x| x.wrapping_mul(12).wrapping_add(40)).map(|x| x.wrapping_mul(13).wrapping_add(40)).map(|x| x.wrapping_mul(14).wrapping_add(40)).map(|x| x.wrapping_mul(15).wrapping_add(40)).map(|x| x.wrapping_mul(16).wrapping_add(40)).map(|x| x.wrapping_mul(17).wrapping_add(40)).map(|x| x.wrapping_mul(18).wrapping_add(40)).map(|x| x.wrapping_mul(19).wrapping_add(40)).map(|x| x.wrapping_mul(20).wrapping_add(40)).map(|x| x.wrapping_mul(21).wrapping_add(40)).map(|x| x.wrapping_mul(22).wrapping_add(40)).map(|x| x.wrapping_mul(23).wrapping_add(40)).map(|x| x.wrapping_mul(24).wrapping_add(40)).map(|x| x.wrapping_mul(25).wrapping_add(40)).map(|x| x.wrapping_mul(26).wrapping_add(40)).map(|x| x.wrapping_mul(27).wrapping_add(40)).map(|x| x.wrapping_mul(28).wrapping_add(40)).map(|x| x.wrapping_mul(29).wrapping_add(40)).map(|x| x.wrapping_mul(30).wrapping_add(40)).map(|x| x.wrapping_mul(31).wrapping_add(40)).map(|x| x.wrapping_mul(32).wrapping_add(40)).map(|x| x.wrapping_mul(33).wrapping_add(40)).map(|x| x.wrapping_mul(34).wrapping_add(40)).map(|x| x.wrapping_mul(35).wrapping_add(40)).map(|x| x.wrapping_mul(36).wrapping_add(40)).map(|x| x.wrapping_mul(37).wrapping_add(40)).map(|x| x.wrapping_mul(38).wrapping_add(40)).map(|x| x.wrapping_mul(39).wrapping_add(40)).map(|x| x.wrapping_mul(40).wrapping_add(40)).map(|x| x.wrapping_mul(41).wrapping_add(40)).map(|x| x.wrapping_mul(42).wrapping_add(40)).fold(0, u64::wrapping_add) } +pub fn busy_41() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(41)).map(|x| x.wrapping_mul(4).wrapping_add(41)).map(|x| x.wrapping_mul(5).wrapping_add(41)).map(|x| x.wrapping_mul(6).wrapping_add(41)).map(|x| x.wrapping_mul(7).wrapping_add(41)).map(|x| x.wrapping_mul(8).wrapping_add(41)).map(|x| x.wrapping_mul(9).wrapping_add(41)).map(|x| x.wrapping_mul(10).wrapping_add(41)).map(|x| x.wrapping_mul(11).wrapping_add(41)).map(|x| x.wrapping_mul(12).wrapping_add(41)).map(|x| x.wrapping_mul(13).wrapping_add(41)).map(|x| x.wrapping_mul(14).wrapping_add(41)).map(|x| x.wrapping_mul(15).wrapping_add(41)).map(|x| x.wrapping_mul(16).wrapping_add(41)).map(|x| x.wrapping_mul(17).wrapping_add(41)).map(|x| x.wrapping_mul(18).wrapping_add(41)).map(|x| x.wrapping_mul(19).wrapping_add(41)).map(|x| x.wrapping_mul(20).wrapping_add(41)).map(|x| x.wrapping_mul(21).wrapping_add(41)).map(|x| x.wrapping_mul(22).wrapping_add(41)).map(|x| x.wrapping_mul(23).wrapping_add(41)).map(|x| x.wrapping_mul(24).wrapping_add(41)).map(|x| x.wrapping_mul(25).wrapping_add(41)).map(|x| x.wrapping_mul(26).wrapping_add(41)).map(|x| x.wrapping_mul(27).wrapping_add(41)).map(|x| x.wrapping_mul(28).wrapping_add(41)).map(|x| x.wrapping_mul(29).wrapping_add(41)).map(|x| x.wrapping_mul(30).wrapping_add(41)).map(|x| x.wrapping_mul(31).wrapping_add(41)).map(|x| x.wrapping_mul(32).wrapping_add(41)).map(|x| x.wrapping_mul(33).wrapping_add(41)).map(|x| x.wrapping_mul(34).wrapping_add(41)).map(|x| x.wrapping_mul(35).wrapping_add(41)).map(|x| x.wrapping_mul(36).wrapping_add(41)).map(|x| x.wrapping_mul(37).wrapping_add(41)).map(|x| x.wrapping_mul(38).wrapping_add(41)).map(|x| x.wrapping_mul(39).wrapping_add(41)).map(|x| x.wrapping_mul(40).wrapping_add(41)).map(|x| x.wrapping_mul(41).wrapping_add(41)).map(|x| x.wrapping_mul(42).wrapping_add(41)).fold(0, u64::wrapping_add) } +pub fn busy_42() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(42)).map(|x| x.wrapping_mul(4).wrapping_add(42)).map(|x| x.wrapping_mul(5).wrapping_add(42)).map(|x| x.wrapping_mul(6).wrapping_add(42)).map(|x| x.wrapping_mul(7).wrapping_add(42)).map(|x| x.wrapping_mul(8).wrapping_add(42)).map(|x| x.wrapping_mul(9).wrapping_add(42)).map(|x| x.wrapping_mul(10).wrapping_add(42)).map(|x| x.wrapping_mul(11).wrapping_add(42)).map(|x| x.wrapping_mul(12).wrapping_add(42)).map(|x| x.wrapping_mul(13).wrapping_add(42)).map(|x| x.wrapping_mul(14).wrapping_add(42)).map(|x| x.wrapping_mul(15).wrapping_add(42)).map(|x| x.wrapping_mul(16).wrapping_add(42)).map(|x| x.wrapping_mul(17).wrapping_add(42)).map(|x| x.wrapping_mul(18).wrapping_add(42)).map(|x| x.wrapping_mul(19).wrapping_add(42)).map(|x| x.wrapping_mul(20).wrapping_add(42)).map(|x| x.wrapping_mul(21).wrapping_add(42)).map(|x| x.wrapping_mul(22).wrapping_add(42)).map(|x| x.wrapping_mul(23).wrapping_add(42)).map(|x| x.wrapping_mul(24).wrapping_add(42)).map(|x| x.wrapping_mul(25).wrapping_add(42)).map(|x| x.wrapping_mul(26).wrapping_add(42)).map(|x| x.wrapping_mul(27).wrapping_add(42)).map(|x| x.wrapping_mul(28).wrapping_add(42)).map(|x| x.wrapping_mul(29).wrapping_add(42)).map(|x| x.wrapping_mul(30).wrapping_add(42)).map(|x| x.wrapping_mul(31).wrapping_add(42)).map(|x| x.wrapping_mul(32).wrapping_add(42)).map(|x| x.wrapping_mul(33).wrapping_add(42)).map(|x| x.wrapping_mul(34).wrapping_add(42)).map(|x| x.wrapping_mul(35).wrapping_add(42)).map(|x| x.wrapping_mul(36).wrapping_add(42)).map(|x| x.wrapping_mul(37).wrapping_add(42)).map(|x| x.wrapping_mul(38).wrapping_add(42)).map(|x| x.wrapping_mul(39).wrapping_add(42)).map(|x| x.wrapping_mul(40).wrapping_add(42)).map(|x| x.wrapping_mul(41).wrapping_add(42)).map(|x| x.wrapping_mul(42).wrapping_add(42)).fold(0, u64::wrapping_add) } +pub fn busy_43() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(43)).map(|x| x.wrapping_mul(4).wrapping_add(43)).map(|x| x.wrapping_mul(5).wrapping_add(43)).map(|x| x.wrapping_mul(6).wrapping_add(43)).map(|x| x.wrapping_mul(7).wrapping_add(43)).map(|x| x.wrapping_mul(8).wrapping_add(43)).map(|x| x.wrapping_mul(9).wrapping_add(43)).map(|x| x.wrapping_mul(10).wrapping_add(43)).map(|x| x.wrapping_mul(11).wrapping_add(43)).map(|x| x.wrapping_mul(12).wrapping_add(43)).map(|x| x.wrapping_mul(13).wrapping_add(43)).map(|x| x.wrapping_mul(14).wrapping_add(43)).map(|x| x.wrapping_mul(15).wrapping_add(43)).map(|x| x.wrapping_mul(16).wrapping_add(43)).map(|x| x.wrapping_mul(17).wrapping_add(43)).map(|x| x.wrapping_mul(18).wrapping_add(43)).map(|x| x.wrapping_mul(19).wrapping_add(43)).map(|x| x.wrapping_mul(20).wrapping_add(43)).map(|x| x.wrapping_mul(21).wrapping_add(43)).map(|x| x.wrapping_mul(22).wrapping_add(43)).map(|x| x.wrapping_mul(23).wrapping_add(43)).map(|x| x.wrapping_mul(24).wrapping_add(43)).map(|x| x.wrapping_mul(25).wrapping_add(43)).map(|x| x.wrapping_mul(26).wrapping_add(43)).map(|x| x.wrapping_mul(27).wrapping_add(43)).map(|x| x.wrapping_mul(28).wrapping_add(43)).map(|x| x.wrapping_mul(29).wrapping_add(43)).map(|x| x.wrapping_mul(30).wrapping_add(43)).map(|x| x.wrapping_mul(31).wrapping_add(43)).map(|x| x.wrapping_mul(32).wrapping_add(43)).map(|x| x.wrapping_mul(33).wrapping_add(43)).map(|x| x.wrapping_mul(34).wrapping_add(43)).map(|x| x.wrapping_mul(35).wrapping_add(43)).map(|x| x.wrapping_mul(36).wrapping_add(43)).map(|x| x.wrapping_mul(37).wrapping_add(43)).map(|x| x.wrapping_mul(38).wrapping_add(43)).map(|x| x.wrapping_mul(39).wrapping_add(43)).map(|x| x.wrapping_mul(40).wrapping_add(43)).map(|x| x.wrapping_mul(41).wrapping_add(43)).map(|x| x.wrapping_mul(42).wrapping_add(43)).fold(0, u64::wrapping_add) } +pub fn busy_44() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(44)).map(|x| x.wrapping_mul(4).wrapping_add(44)).map(|x| x.wrapping_mul(5).wrapping_add(44)).map(|x| x.wrapping_mul(6).wrapping_add(44)).map(|x| x.wrapping_mul(7).wrapping_add(44)).map(|x| x.wrapping_mul(8).wrapping_add(44)).map(|x| x.wrapping_mul(9).wrapping_add(44)).map(|x| x.wrapping_mul(10).wrapping_add(44)).map(|x| x.wrapping_mul(11).wrapping_add(44)).map(|x| x.wrapping_mul(12).wrapping_add(44)).map(|x| x.wrapping_mul(13).wrapping_add(44)).map(|x| x.wrapping_mul(14).wrapping_add(44)).map(|x| x.wrapping_mul(15).wrapping_add(44)).map(|x| x.wrapping_mul(16).wrapping_add(44)).map(|x| x.wrapping_mul(17).wrapping_add(44)).map(|x| x.wrapping_mul(18).wrapping_add(44)).map(|x| x.wrapping_mul(19).wrapping_add(44)).map(|x| x.wrapping_mul(20).wrapping_add(44)).map(|x| x.wrapping_mul(21).wrapping_add(44)).map(|x| x.wrapping_mul(22).wrapping_add(44)).map(|x| x.wrapping_mul(23).wrapping_add(44)).map(|x| x.wrapping_mul(24).wrapping_add(44)).map(|x| x.wrapping_mul(25).wrapping_add(44)).map(|x| x.wrapping_mul(26).wrapping_add(44)).map(|x| x.wrapping_mul(27).wrapping_add(44)).map(|x| x.wrapping_mul(28).wrapping_add(44)).map(|x| x.wrapping_mul(29).wrapping_add(44)).map(|x| x.wrapping_mul(30).wrapping_add(44)).map(|x| x.wrapping_mul(31).wrapping_add(44)).map(|x| x.wrapping_mul(32).wrapping_add(44)).map(|x| x.wrapping_mul(33).wrapping_add(44)).map(|x| x.wrapping_mul(34).wrapping_add(44)).map(|x| x.wrapping_mul(35).wrapping_add(44)).map(|x| x.wrapping_mul(36).wrapping_add(44)).map(|x| x.wrapping_mul(37).wrapping_add(44)).map(|x| x.wrapping_mul(38).wrapping_add(44)).map(|x| x.wrapping_mul(39).wrapping_add(44)).map(|x| x.wrapping_mul(40).wrapping_add(44)).map(|x| x.wrapping_mul(41).wrapping_add(44)).map(|x| x.wrapping_mul(42).wrapping_add(44)).fold(0, u64::wrapping_add) } +pub fn busy_45() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(45)).map(|x| x.wrapping_mul(4).wrapping_add(45)).map(|x| x.wrapping_mul(5).wrapping_add(45)).map(|x| x.wrapping_mul(6).wrapping_add(45)).map(|x| x.wrapping_mul(7).wrapping_add(45)).map(|x| x.wrapping_mul(8).wrapping_add(45)).map(|x| x.wrapping_mul(9).wrapping_add(45)).map(|x| x.wrapping_mul(10).wrapping_add(45)).map(|x| x.wrapping_mul(11).wrapping_add(45)).map(|x| x.wrapping_mul(12).wrapping_add(45)).map(|x| x.wrapping_mul(13).wrapping_add(45)).map(|x| x.wrapping_mul(14).wrapping_add(45)).map(|x| x.wrapping_mul(15).wrapping_add(45)).map(|x| x.wrapping_mul(16).wrapping_add(45)).map(|x| x.wrapping_mul(17).wrapping_add(45)).map(|x| x.wrapping_mul(18).wrapping_add(45)).map(|x| x.wrapping_mul(19).wrapping_add(45)).map(|x| x.wrapping_mul(20).wrapping_add(45)).map(|x| x.wrapping_mul(21).wrapping_add(45)).map(|x| x.wrapping_mul(22).wrapping_add(45)).map(|x| x.wrapping_mul(23).wrapping_add(45)).map(|x| x.wrapping_mul(24).wrapping_add(45)).map(|x| x.wrapping_mul(25).wrapping_add(45)).map(|x| x.wrapping_mul(26).wrapping_add(45)).map(|x| x.wrapping_mul(27).wrapping_add(45)).map(|x| x.wrapping_mul(28).wrapping_add(45)).map(|x| x.wrapping_mul(29).wrapping_add(45)).map(|x| x.wrapping_mul(30).wrapping_add(45)).map(|x| x.wrapping_mul(31).wrapping_add(45)).map(|x| x.wrapping_mul(32).wrapping_add(45)).map(|x| x.wrapping_mul(33).wrapping_add(45)).map(|x| x.wrapping_mul(34).wrapping_add(45)).map(|x| x.wrapping_mul(35).wrapping_add(45)).map(|x| x.wrapping_mul(36).wrapping_add(45)).map(|x| x.wrapping_mul(37).wrapping_add(45)).map(|x| x.wrapping_mul(38).wrapping_add(45)).map(|x| x.wrapping_mul(39).wrapping_add(45)).map(|x| x.wrapping_mul(40).wrapping_add(45)).map(|x| x.wrapping_mul(41).wrapping_add(45)).map(|x| x.wrapping_mul(42).wrapping_add(45)).fold(0, u64::wrapping_add) } +pub fn busy_46() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(46)).map(|x| x.wrapping_mul(4).wrapping_add(46)).map(|x| x.wrapping_mul(5).wrapping_add(46)).map(|x| x.wrapping_mul(6).wrapping_add(46)).map(|x| x.wrapping_mul(7).wrapping_add(46)).map(|x| x.wrapping_mul(8).wrapping_add(46)).map(|x| x.wrapping_mul(9).wrapping_add(46)).map(|x| x.wrapping_mul(10).wrapping_add(46)).map(|x| x.wrapping_mul(11).wrapping_add(46)).map(|x| x.wrapping_mul(12).wrapping_add(46)).map(|x| x.wrapping_mul(13).wrapping_add(46)).map(|x| x.wrapping_mul(14).wrapping_add(46)).map(|x| x.wrapping_mul(15).wrapping_add(46)).map(|x| x.wrapping_mul(16).wrapping_add(46)).map(|x| x.wrapping_mul(17).wrapping_add(46)).map(|x| x.wrapping_mul(18).wrapping_add(46)).map(|x| x.wrapping_mul(19).wrapping_add(46)).map(|x| x.wrapping_mul(20).wrapping_add(46)).map(|x| x.wrapping_mul(21).wrapping_add(46)).map(|x| x.wrapping_mul(22).wrapping_add(46)).map(|x| x.wrapping_mul(23).wrapping_add(46)).map(|x| x.wrapping_mul(24).wrapping_add(46)).map(|x| x.wrapping_mul(25).wrapping_add(46)).map(|x| x.wrapping_mul(26).wrapping_add(46)).map(|x| x.wrapping_mul(27).wrapping_add(46)).map(|x| x.wrapping_mul(28).wrapping_add(46)).map(|x| x.wrapping_mul(29).wrapping_add(46)).map(|x| x.wrapping_mul(30).wrapping_add(46)).map(|x| x.wrapping_mul(31).wrapping_add(46)).map(|x| x.wrapping_mul(32).wrapping_add(46)).map(|x| x.wrapping_mul(33).wrapping_add(46)).map(|x| x.wrapping_mul(34).wrapping_add(46)).map(|x| x.wrapping_mul(35).wrapping_add(46)).map(|x| x.wrapping_mul(36).wrapping_add(46)).map(|x| x.wrapping_mul(37).wrapping_add(46)).map(|x| x.wrapping_mul(38).wrapping_add(46)).map(|x| x.wrapping_mul(39).wrapping_add(46)).map(|x| x.wrapping_mul(40).wrapping_add(46)).map(|x| x.wrapping_mul(41).wrapping_add(46)).map(|x| x.wrapping_mul(42).wrapping_add(46)).fold(0, u64::wrapping_add) } +pub fn busy_47() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(47)).map(|x| x.wrapping_mul(4).wrapping_add(47)).map(|x| x.wrapping_mul(5).wrapping_add(47)).map(|x| x.wrapping_mul(6).wrapping_add(47)).map(|x| x.wrapping_mul(7).wrapping_add(47)).map(|x| x.wrapping_mul(8).wrapping_add(47)).map(|x| x.wrapping_mul(9).wrapping_add(47)).map(|x| x.wrapping_mul(10).wrapping_add(47)).map(|x| x.wrapping_mul(11).wrapping_add(47)).map(|x| x.wrapping_mul(12).wrapping_add(47)).map(|x| x.wrapping_mul(13).wrapping_add(47)).map(|x| x.wrapping_mul(14).wrapping_add(47)).map(|x| x.wrapping_mul(15).wrapping_add(47)).map(|x| x.wrapping_mul(16).wrapping_add(47)).map(|x| x.wrapping_mul(17).wrapping_add(47)).map(|x| x.wrapping_mul(18).wrapping_add(47)).map(|x| x.wrapping_mul(19).wrapping_add(47)).map(|x| x.wrapping_mul(20).wrapping_add(47)).map(|x| x.wrapping_mul(21).wrapping_add(47)).map(|x| x.wrapping_mul(22).wrapping_add(47)).map(|x| x.wrapping_mul(23).wrapping_add(47)).map(|x| x.wrapping_mul(24).wrapping_add(47)).map(|x| x.wrapping_mul(25).wrapping_add(47)).map(|x| x.wrapping_mul(26).wrapping_add(47)).map(|x| x.wrapping_mul(27).wrapping_add(47)).map(|x| x.wrapping_mul(28).wrapping_add(47)).map(|x| x.wrapping_mul(29).wrapping_add(47)).map(|x| x.wrapping_mul(30).wrapping_add(47)).map(|x| x.wrapping_mul(31).wrapping_add(47)).map(|x| x.wrapping_mul(32).wrapping_add(47)).map(|x| x.wrapping_mul(33).wrapping_add(47)).map(|x| x.wrapping_mul(34).wrapping_add(47)).map(|x| x.wrapping_mul(35).wrapping_add(47)).map(|x| x.wrapping_mul(36).wrapping_add(47)).map(|x| x.wrapping_mul(37).wrapping_add(47)).map(|x| x.wrapping_mul(38).wrapping_add(47)).map(|x| x.wrapping_mul(39).wrapping_add(47)).map(|x| x.wrapping_mul(40).wrapping_add(47)).map(|x| x.wrapping_mul(41).wrapping_add(47)).map(|x| x.wrapping_mul(42).wrapping_add(47)).fold(0, u64::wrapping_add) } +pub fn busy_48() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(48)).map(|x| x.wrapping_mul(4).wrapping_add(48)).map(|x| x.wrapping_mul(5).wrapping_add(48)).map(|x| x.wrapping_mul(6).wrapping_add(48)).map(|x| x.wrapping_mul(7).wrapping_add(48)).map(|x| x.wrapping_mul(8).wrapping_add(48)).map(|x| x.wrapping_mul(9).wrapping_add(48)).map(|x| x.wrapping_mul(10).wrapping_add(48)).map(|x| x.wrapping_mul(11).wrapping_add(48)).map(|x| x.wrapping_mul(12).wrapping_add(48)).map(|x| x.wrapping_mul(13).wrapping_add(48)).map(|x| x.wrapping_mul(14).wrapping_add(48)).map(|x| x.wrapping_mul(15).wrapping_add(48)).map(|x| x.wrapping_mul(16).wrapping_add(48)).map(|x| x.wrapping_mul(17).wrapping_add(48)).map(|x| x.wrapping_mul(18).wrapping_add(48)).map(|x| x.wrapping_mul(19).wrapping_add(48)).map(|x| x.wrapping_mul(20).wrapping_add(48)).map(|x| x.wrapping_mul(21).wrapping_add(48)).map(|x| x.wrapping_mul(22).wrapping_add(48)).map(|x| x.wrapping_mul(23).wrapping_add(48)).map(|x| x.wrapping_mul(24).wrapping_add(48)).map(|x| x.wrapping_mul(25).wrapping_add(48)).map(|x| x.wrapping_mul(26).wrapping_add(48)).map(|x| x.wrapping_mul(27).wrapping_add(48)).map(|x| x.wrapping_mul(28).wrapping_add(48)).map(|x| x.wrapping_mul(29).wrapping_add(48)).map(|x| x.wrapping_mul(30).wrapping_add(48)).map(|x| x.wrapping_mul(31).wrapping_add(48)).map(|x| x.wrapping_mul(32).wrapping_add(48)).map(|x| x.wrapping_mul(33).wrapping_add(48)).map(|x| x.wrapping_mul(34).wrapping_add(48)).map(|x| x.wrapping_mul(35).wrapping_add(48)).map(|x| x.wrapping_mul(36).wrapping_add(48)).map(|x| x.wrapping_mul(37).wrapping_add(48)).map(|x| x.wrapping_mul(38).wrapping_add(48)).map(|x| x.wrapping_mul(39).wrapping_add(48)).map(|x| x.wrapping_mul(40).wrapping_add(48)).map(|x| x.wrapping_mul(41).wrapping_add(48)).map(|x| x.wrapping_mul(42).wrapping_add(48)).fold(0, u64::wrapping_add) } +pub fn busy_49() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(49)).map(|x| x.wrapping_mul(4).wrapping_add(49)).map(|x| x.wrapping_mul(5).wrapping_add(49)).map(|x| x.wrapping_mul(6).wrapping_add(49)).map(|x| x.wrapping_mul(7).wrapping_add(49)).map(|x| x.wrapping_mul(8).wrapping_add(49)).map(|x| x.wrapping_mul(9).wrapping_add(49)).map(|x| x.wrapping_mul(10).wrapping_add(49)).map(|x| x.wrapping_mul(11).wrapping_add(49)).map(|x| x.wrapping_mul(12).wrapping_add(49)).map(|x| x.wrapping_mul(13).wrapping_add(49)).map(|x| x.wrapping_mul(14).wrapping_add(49)).map(|x| x.wrapping_mul(15).wrapping_add(49)).map(|x| x.wrapping_mul(16).wrapping_add(49)).map(|x| x.wrapping_mul(17).wrapping_add(49)).map(|x| x.wrapping_mul(18).wrapping_add(49)).map(|x| x.wrapping_mul(19).wrapping_add(49)).map(|x| x.wrapping_mul(20).wrapping_add(49)).map(|x| x.wrapping_mul(21).wrapping_add(49)).map(|x| x.wrapping_mul(22).wrapping_add(49)).map(|x| x.wrapping_mul(23).wrapping_add(49)).map(|x| x.wrapping_mul(24).wrapping_add(49)).map(|x| x.wrapping_mul(25).wrapping_add(49)).map(|x| x.wrapping_mul(26).wrapping_add(49)).map(|x| x.wrapping_mul(27).wrapping_add(49)).map(|x| x.wrapping_mul(28).wrapping_add(49)).map(|x| x.wrapping_mul(29).wrapping_add(49)).map(|x| x.wrapping_mul(30).wrapping_add(49)).map(|x| x.wrapping_mul(31).wrapping_add(49)).map(|x| x.wrapping_mul(32).wrapping_add(49)).map(|x| x.wrapping_mul(33).wrapping_add(49)).map(|x| x.wrapping_mul(34).wrapping_add(49)).map(|x| x.wrapping_mul(35).wrapping_add(49)).map(|x| x.wrapping_mul(36).wrapping_add(49)).map(|x| x.wrapping_mul(37).wrapping_add(49)).map(|x| x.wrapping_mul(38).wrapping_add(49)).map(|x| x.wrapping_mul(39).wrapping_add(49)).map(|x| x.wrapping_mul(40).wrapping_add(49)).map(|x| x.wrapping_mul(41).wrapping_add(49)).map(|x| x.wrapping_mul(42).wrapping_add(49)).fold(0, u64::wrapping_add) } +pub fn busy_50() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(50)).map(|x| x.wrapping_mul(4).wrapping_add(50)).map(|x| x.wrapping_mul(5).wrapping_add(50)).map(|x| x.wrapping_mul(6).wrapping_add(50)).map(|x| x.wrapping_mul(7).wrapping_add(50)).map(|x| x.wrapping_mul(8).wrapping_add(50)).map(|x| x.wrapping_mul(9).wrapping_add(50)).map(|x| x.wrapping_mul(10).wrapping_add(50)).map(|x| x.wrapping_mul(11).wrapping_add(50)).map(|x| x.wrapping_mul(12).wrapping_add(50)).map(|x| x.wrapping_mul(13).wrapping_add(50)).map(|x| x.wrapping_mul(14).wrapping_add(50)).map(|x| x.wrapping_mul(15).wrapping_add(50)).map(|x| x.wrapping_mul(16).wrapping_add(50)).map(|x| x.wrapping_mul(17).wrapping_add(50)).map(|x| x.wrapping_mul(18).wrapping_add(50)).map(|x| x.wrapping_mul(19).wrapping_add(50)).map(|x| x.wrapping_mul(20).wrapping_add(50)).map(|x| x.wrapping_mul(21).wrapping_add(50)).map(|x| x.wrapping_mul(22).wrapping_add(50)).map(|x| x.wrapping_mul(23).wrapping_add(50)).map(|x| x.wrapping_mul(24).wrapping_add(50)).map(|x| x.wrapping_mul(25).wrapping_add(50)).map(|x| x.wrapping_mul(26).wrapping_add(50)).map(|x| x.wrapping_mul(27).wrapping_add(50)).map(|x| x.wrapping_mul(28).wrapping_add(50)).map(|x| x.wrapping_mul(29).wrapping_add(50)).map(|x| x.wrapping_mul(30).wrapping_add(50)).map(|x| x.wrapping_mul(31).wrapping_add(50)).map(|x| x.wrapping_mul(32).wrapping_add(50)).map(|x| x.wrapping_mul(33).wrapping_add(50)).map(|x| x.wrapping_mul(34).wrapping_add(50)).map(|x| x.wrapping_mul(35).wrapping_add(50)).map(|x| x.wrapping_mul(36).wrapping_add(50)).map(|x| x.wrapping_mul(37).wrapping_add(50)).map(|x| x.wrapping_mul(38).wrapping_add(50)).map(|x| x.wrapping_mul(39).wrapping_add(50)).map(|x| x.wrapping_mul(40).wrapping_add(50)).map(|x| x.wrapping_mul(41).wrapping_add(50)).map(|x| x.wrapping_mul(42).wrapping_add(50)).fold(0, u64::wrapping_add) } +pub fn busy_51() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(51)).map(|x| x.wrapping_mul(4).wrapping_add(51)).map(|x| x.wrapping_mul(5).wrapping_add(51)).map(|x| x.wrapping_mul(6).wrapping_add(51)).map(|x| x.wrapping_mul(7).wrapping_add(51)).map(|x| x.wrapping_mul(8).wrapping_add(51)).map(|x| x.wrapping_mul(9).wrapping_add(51)).map(|x| x.wrapping_mul(10).wrapping_add(51)).map(|x| x.wrapping_mul(11).wrapping_add(51)).map(|x| x.wrapping_mul(12).wrapping_add(51)).map(|x| x.wrapping_mul(13).wrapping_add(51)).map(|x| x.wrapping_mul(14).wrapping_add(51)).map(|x| x.wrapping_mul(15).wrapping_add(51)).map(|x| x.wrapping_mul(16).wrapping_add(51)).map(|x| x.wrapping_mul(17).wrapping_add(51)).map(|x| x.wrapping_mul(18).wrapping_add(51)).map(|x| x.wrapping_mul(19).wrapping_add(51)).map(|x| x.wrapping_mul(20).wrapping_add(51)).map(|x| x.wrapping_mul(21).wrapping_add(51)).map(|x| x.wrapping_mul(22).wrapping_add(51)).map(|x| x.wrapping_mul(23).wrapping_add(51)).map(|x| x.wrapping_mul(24).wrapping_add(51)).map(|x| x.wrapping_mul(25).wrapping_add(51)).map(|x| x.wrapping_mul(26).wrapping_add(51)).map(|x| x.wrapping_mul(27).wrapping_add(51)).map(|x| x.wrapping_mul(28).wrapping_add(51)).map(|x| x.wrapping_mul(29).wrapping_add(51)).map(|x| x.wrapping_mul(30).wrapping_add(51)).map(|x| x.wrapping_mul(31).wrapping_add(51)).map(|x| x.wrapping_mul(32).wrapping_add(51)).map(|x| x.wrapping_mul(33).wrapping_add(51)).map(|x| x.wrapping_mul(34).wrapping_add(51)).map(|x| x.wrapping_mul(35).wrapping_add(51)).map(|x| x.wrapping_mul(36).wrapping_add(51)).map(|x| x.wrapping_mul(37).wrapping_add(51)).map(|x| x.wrapping_mul(38).wrapping_add(51)).map(|x| x.wrapping_mul(39).wrapping_add(51)).map(|x| x.wrapping_mul(40).wrapping_add(51)).map(|x| x.wrapping_mul(41).wrapping_add(51)).map(|x| x.wrapping_mul(42).wrapping_add(51)).fold(0, u64::wrapping_add) } +pub fn busy_52() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(52)).map(|x| x.wrapping_mul(4).wrapping_add(52)).map(|x| x.wrapping_mul(5).wrapping_add(52)).map(|x| x.wrapping_mul(6).wrapping_add(52)).map(|x| x.wrapping_mul(7).wrapping_add(52)).map(|x| x.wrapping_mul(8).wrapping_add(52)).map(|x| x.wrapping_mul(9).wrapping_add(52)).map(|x| x.wrapping_mul(10).wrapping_add(52)).map(|x| x.wrapping_mul(11).wrapping_add(52)).map(|x| x.wrapping_mul(12).wrapping_add(52)).map(|x| x.wrapping_mul(13).wrapping_add(52)).map(|x| x.wrapping_mul(14).wrapping_add(52)).map(|x| x.wrapping_mul(15).wrapping_add(52)).map(|x| x.wrapping_mul(16).wrapping_add(52)).map(|x| x.wrapping_mul(17).wrapping_add(52)).map(|x| x.wrapping_mul(18).wrapping_add(52)).map(|x| x.wrapping_mul(19).wrapping_add(52)).map(|x| x.wrapping_mul(20).wrapping_add(52)).map(|x| x.wrapping_mul(21).wrapping_add(52)).map(|x| x.wrapping_mul(22).wrapping_add(52)).map(|x| x.wrapping_mul(23).wrapping_add(52)).map(|x| x.wrapping_mul(24).wrapping_add(52)).map(|x| x.wrapping_mul(25).wrapping_add(52)).map(|x| x.wrapping_mul(26).wrapping_add(52)).map(|x| x.wrapping_mul(27).wrapping_add(52)).map(|x| x.wrapping_mul(28).wrapping_add(52)).map(|x| x.wrapping_mul(29).wrapping_add(52)).map(|x| x.wrapping_mul(30).wrapping_add(52)).map(|x| x.wrapping_mul(31).wrapping_add(52)).map(|x| x.wrapping_mul(32).wrapping_add(52)).map(|x| x.wrapping_mul(33).wrapping_add(52)).map(|x| x.wrapping_mul(34).wrapping_add(52)).map(|x| x.wrapping_mul(35).wrapping_add(52)).map(|x| x.wrapping_mul(36).wrapping_add(52)).map(|x| x.wrapping_mul(37).wrapping_add(52)).map(|x| x.wrapping_mul(38).wrapping_add(52)).map(|x| x.wrapping_mul(39).wrapping_add(52)).map(|x| x.wrapping_mul(40).wrapping_add(52)).map(|x| x.wrapping_mul(41).wrapping_add(52)).map(|x| x.wrapping_mul(42).wrapping_add(52)).fold(0, u64::wrapping_add) } +pub fn busy_53() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(53)).map(|x| x.wrapping_mul(4).wrapping_add(53)).map(|x| x.wrapping_mul(5).wrapping_add(53)).map(|x| x.wrapping_mul(6).wrapping_add(53)).map(|x| x.wrapping_mul(7).wrapping_add(53)).map(|x| x.wrapping_mul(8).wrapping_add(53)).map(|x| x.wrapping_mul(9).wrapping_add(53)).map(|x| x.wrapping_mul(10).wrapping_add(53)).map(|x| x.wrapping_mul(11).wrapping_add(53)).map(|x| x.wrapping_mul(12).wrapping_add(53)).map(|x| x.wrapping_mul(13).wrapping_add(53)).map(|x| x.wrapping_mul(14).wrapping_add(53)).map(|x| x.wrapping_mul(15).wrapping_add(53)).map(|x| x.wrapping_mul(16).wrapping_add(53)).map(|x| x.wrapping_mul(17).wrapping_add(53)).map(|x| x.wrapping_mul(18).wrapping_add(53)).map(|x| x.wrapping_mul(19).wrapping_add(53)).map(|x| x.wrapping_mul(20).wrapping_add(53)).map(|x| x.wrapping_mul(21).wrapping_add(53)).map(|x| x.wrapping_mul(22).wrapping_add(53)).map(|x| x.wrapping_mul(23).wrapping_add(53)).map(|x| x.wrapping_mul(24).wrapping_add(53)).map(|x| x.wrapping_mul(25).wrapping_add(53)).map(|x| x.wrapping_mul(26).wrapping_add(53)).map(|x| x.wrapping_mul(27).wrapping_add(53)).map(|x| x.wrapping_mul(28).wrapping_add(53)).map(|x| x.wrapping_mul(29).wrapping_add(53)).map(|x| x.wrapping_mul(30).wrapping_add(53)).map(|x| x.wrapping_mul(31).wrapping_add(53)).map(|x| x.wrapping_mul(32).wrapping_add(53)).map(|x| x.wrapping_mul(33).wrapping_add(53)).map(|x| x.wrapping_mul(34).wrapping_add(53)).map(|x| x.wrapping_mul(35).wrapping_add(53)).map(|x| x.wrapping_mul(36).wrapping_add(53)).map(|x| x.wrapping_mul(37).wrapping_add(53)).map(|x| x.wrapping_mul(38).wrapping_add(53)).map(|x| x.wrapping_mul(39).wrapping_add(53)).map(|x| x.wrapping_mul(40).wrapping_add(53)).map(|x| x.wrapping_mul(41).wrapping_add(53)).map(|x| x.wrapping_mul(42).wrapping_add(53)).fold(0, u64::wrapping_add) } +pub fn busy_54() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(54)).map(|x| x.wrapping_mul(4).wrapping_add(54)).map(|x| x.wrapping_mul(5).wrapping_add(54)).map(|x| x.wrapping_mul(6).wrapping_add(54)).map(|x| x.wrapping_mul(7).wrapping_add(54)).map(|x| x.wrapping_mul(8).wrapping_add(54)).map(|x| x.wrapping_mul(9).wrapping_add(54)).map(|x| x.wrapping_mul(10).wrapping_add(54)).map(|x| x.wrapping_mul(11).wrapping_add(54)).map(|x| x.wrapping_mul(12).wrapping_add(54)).map(|x| x.wrapping_mul(13).wrapping_add(54)).map(|x| x.wrapping_mul(14).wrapping_add(54)).map(|x| x.wrapping_mul(15).wrapping_add(54)).map(|x| x.wrapping_mul(16).wrapping_add(54)).map(|x| x.wrapping_mul(17).wrapping_add(54)).map(|x| x.wrapping_mul(18).wrapping_add(54)).map(|x| x.wrapping_mul(19).wrapping_add(54)).map(|x| x.wrapping_mul(20).wrapping_add(54)).map(|x| x.wrapping_mul(21).wrapping_add(54)).map(|x| x.wrapping_mul(22).wrapping_add(54)).map(|x| x.wrapping_mul(23).wrapping_add(54)).map(|x| x.wrapping_mul(24).wrapping_add(54)).map(|x| x.wrapping_mul(25).wrapping_add(54)).map(|x| x.wrapping_mul(26).wrapping_add(54)).map(|x| x.wrapping_mul(27).wrapping_add(54)).map(|x| x.wrapping_mul(28).wrapping_add(54)).map(|x| x.wrapping_mul(29).wrapping_add(54)).map(|x| x.wrapping_mul(30).wrapping_add(54)).map(|x| x.wrapping_mul(31).wrapping_add(54)).map(|x| x.wrapping_mul(32).wrapping_add(54)).map(|x| x.wrapping_mul(33).wrapping_add(54)).map(|x| x.wrapping_mul(34).wrapping_add(54)).map(|x| x.wrapping_mul(35).wrapping_add(54)).map(|x| x.wrapping_mul(36).wrapping_add(54)).map(|x| x.wrapping_mul(37).wrapping_add(54)).map(|x| x.wrapping_mul(38).wrapping_add(54)).map(|x| x.wrapping_mul(39).wrapping_add(54)).map(|x| x.wrapping_mul(40).wrapping_add(54)).map(|x| x.wrapping_mul(41).wrapping_add(54)).map(|x| x.wrapping_mul(42).wrapping_add(54)).fold(0, u64::wrapping_add) } +pub fn busy_55() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(55)).map(|x| x.wrapping_mul(4).wrapping_add(55)).map(|x| x.wrapping_mul(5).wrapping_add(55)).map(|x| x.wrapping_mul(6).wrapping_add(55)).map(|x| x.wrapping_mul(7).wrapping_add(55)).map(|x| x.wrapping_mul(8).wrapping_add(55)).map(|x| x.wrapping_mul(9).wrapping_add(55)).map(|x| x.wrapping_mul(10).wrapping_add(55)).map(|x| x.wrapping_mul(11).wrapping_add(55)).map(|x| x.wrapping_mul(12).wrapping_add(55)).map(|x| x.wrapping_mul(13).wrapping_add(55)).map(|x| x.wrapping_mul(14).wrapping_add(55)).map(|x| x.wrapping_mul(15).wrapping_add(55)).map(|x| x.wrapping_mul(16).wrapping_add(55)).map(|x| x.wrapping_mul(17).wrapping_add(55)).map(|x| x.wrapping_mul(18).wrapping_add(55)).map(|x| x.wrapping_mul(19).wrapping_add(55)).map(|x| x.wrapping_mul(20).wrapping_add(55)).map(|x| x.wrapping_mul(21).wrapping_add(55)).map(|x| x.wrapping_mul(22).wrapping_add(55)).map(|x| x.wrapping_mul(23).wrapping_add(55)).map(|x| x.wrapping_mul(24).wrapping_add(55)).map(|x| x.wrapping_mul(25).wrapping_add(55)).map(|x| x.wrapping_mul(26).wrapping_add(55)).map(|x| x.wrapping_mul(27).wrapping_add(55)).map(|x| x.wrapping_mul(28).wrapping_add(55)).map(|x| x.wrapping_mul(29).wrapping_add(55)).map(|x| x.wrapping_mul(30).wrapping_add(55)).map(|x| x.wrapping_mul(31).wrapping_add(55)).map(|x| x.wrapping_mul(32).wrapping_add(55)).map(|x| x.wrapping_mul(33).wrapping_add(55)).map(|x| x.wrapping_mul(34).wrapping_add(55)).map(|x| x.wrapping_mul(35).wrapping_add(55)).map(|x| x.wrapping_mul(36).wrapping_add(55)).map(|x| x.wrapping_mul(37).wrapping_add(55)).map(|x| x.wrapping_mul(38).wrapping_add(55)).map(|x| x.wrapping_mul(39).wrapping_add(55)).map(|x| x.wrapping_mul(40).wrapping_add(55)).map(|x| x.wrapping_mul(41).wrapping_add(55)).map(|x| x.wrapping_mul(42).wrapping_add(55)).fold(0, u64::wrapping_add) } +pub fn busy_56() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(56)).map(|x| x.wrapping_mul(4).wrapping_add(56)).map(|x| x.wrapping_mul(5).wrapping_add(56)).map(|x| x.wrapping_mul(6).wrapping_add(56)).map(|x| x.wrapping_mul(7).wrapping_add(56)).map(|x| x.wrapping_mul(8).wrapping_add(56)).map(|x| x.wrapping_mul(9).wrapping_add(56)).map(|x| x.wrapping_mul(10).wrapping_add(56)).map(|x| x.wrapping_mul(11).wrapping_add(56)).map(|x| x.wrapping_mul(12).wrapping_add(56)).map(|x| x.wrapping_mul(13).wrapping_add(56)).map(|x| x.wrapping_mul(14).wrapping_add(56)).map(|x| x.wrapping_mul(15).wrapping_add(56)).map(|x| x.wrapping_mul(16).wrapping_add(56)).map(|x| x.wrapping_mul(17).wrapping_add(56)).map(|x| x.wrapping_mul(18).wrapping_add(56)).map(|x| x.wrapping_mul(19).wrapping_add(56)).map(|x| x.wrapping_mul(20).wrapping_add(56)).map(|x| x.wrapping_mul(21).wrapping_add(56)).map(|x| x.wrapping_mul(22).wrapping_add(56)).map(|x| x.wrapping_mul(23).wrapping_add(56)).map(|x| x.wrapping_mul(24).wrapping_add(56)).map(|x| x.wrapping_mul(25).wrapping_add(56)).map(|x| x.wrapping_mul(26).wrapping_add(56)).map(|x| x.wrapping_mul(27).wrapping_add(56)).map(|x| x.wrapping_mul(28).wrapping_add(56)).map(|x| x.wrapping_mul(29).wrapping_add(56)).map(|x| x.wrapping_mul(30).wrapping_add(56)).map(|x| x.wrapping_mul(31).wrapping_add(56)).map(|x| x.wrapping_mul(32).wrapping_add(56)).map(|x| x.wrapping_mul(33).wrapping_add(56)).map(|x| x.wrapping_mul(34).wrapping_add(56)).map(|x| x.wrapping_mul(35).wrapping_add(56)).map(|x| x.wrapping_mul(36).wrapping_add(56)).map(|x| x.wrapping_mul(37).wrapping_add(56)).map(|x| x.wrapping_mul(38).wrapping_add(56)).map(|x| x.wrapping_mul(39).wrapping_add(56)).map(|x| x.wrapping_mul(40).wrapping_add(56)).map(|x| x.wrapping_mul(41).wrapping_add(56)).map(|x| x.wrapping_mul(42).wrapping_add(56)).fold(0, u64::wrapping_add) } +pub fn busy_57() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(57)).map(|x| x.wrapping_mul(4).wrapping_add(57)).map(|x| x.wrapping_mul(5).wrapping_add(57)).map(|x| x.wrapping_mul(6).wrapping_add(57)).map(|x| x.wrapping_mul(7).wrapping_add(57)).map(|x| x.wrapping_mul(8).wrapping_add(57)).map(|x| x.wrapping_mul(9).wrapping_add(57)).map(|x| x.wrapping_mul(10).wrapping_add(57)).map(|x| x.wrapping_mul(11).wrapping_add(57)).map(|x| x.wrapping_mul(12).wrapping_add(57)).map(|x| x.wrapping_mul(13).wrapping_add(57)).map(|x| x.wrapping_mul(14).wrapping_add(57)).map(|x| x.wrapping_mul(15).wrapping_add(57)).map(|x| x.wrapping_mul(16).wrapping_add(57)).map(|x| x.wrapping_mul(17).wrapping_add(57)).map(|x| x.wrapping_mul(18).wrapping_add(57)).map(|x| x.wrapping_mul(19).wrapping_add(57)).map(|x| x.wrapping_mul(20).wrapping_add(57)).map(|x| x.wrapping_mul(21).wrapping_add(57)).map(|x| x.wrapping_mul(22).wrapping_add(57)).map(|x| x.wrapping_mul(23).wrapping_add(57)).map(|x| x.wrapping_mul(24).wrapping_add(57)).map(|x| x.wrapping_mul(25).wrapping_add(57)).map(|x| x.wrapping_mul(26).wrapping_add(57)).map(|x| x.wrapping_mul(27).wrapping_add(57)).map(|x| x.wrapping_mul(28).wrapping_add(57)).map(|x| x.wrapping_mul(29).wrapping_add(57)).map(|x| x.wrapping_mul(30).wrapping_add(57)).map(|x| x.wrapping_mul(31).wrapping_add(57)).map(|x| x.wrapping_mul(32).wrapping_add(57)).map(|x| x.wrapping_mul(33).wrapping_add(57)).map(|x| x.wrapping_mul(34).wrapping_add(57)).map(|x| x.wrapping_mul(35).wrapping_add(57)).map(|x| x.wrapping_mul(36).wrapping_add(57)).map(|x| x.wrapping_mul(37).wrapping_add(57)).map(|x| x.wrapping_mul(38).wrapping_add(57)).map(|x| x.wrapping_mul(39).wrapping_add(57)).map(|x| x.wrapping_mul(40).wrapping_add(57)).map(|x| x.wrapping_mul(41).wrapping_add(57)).map(|x| x.wrapping_mul(42).wrapping_add(57)).fold(0, u64::wrapping_add) } +pub fn busy_58() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(58)).map(|x| x.wrapping_mul(4).wrapping_add(58)).map(|x| x.wrapping_mul(5).wrapping_add(58)).map(|x| x.wrapping_mul(6).wrapping_add(58)).map(|x| x.wrapping_mul(7).wrapping_add(58)).map(|x| x.wrapping_mul(8).wrapping_add(58)).map(|x| x.wrapping_mul(9).wrapping_add(58)).map(|x| x.wrapping_mul(10).wrapping_add(58)).map(|x| x.wrapping_mul(11).wrapping_add(58)).map(|x| x.wrapping_mul(12).wrapping_add(58)).map(|x| x.wrapping_mul(13).wrapping_add(58)).map(|x| x.wrapping_mul(14).wrapping_add(58)).map(|x| x.wrapping_mul(15).wrapping_add(58)).map(|x| x.wrapping_mul(16).wrapping_add(58)).map(|x| x.wrapping_mul(17).wrapping_add(58)).map(|x| x.wrapping_mul(18).wrapping_add(58)).map(|x| x.wrapping_mul(19).wrapping_add(58)).map(|x| x.wrapping_mul(20).wrapping_add(58)).map(|x| x.wrapping_mul(21).wrapping_add(58)).map(|x| x.wrapping_mul(22).wrapping_add(58)).map(|x| x.wrapping_mul(23).wrapping_add(58)).map(|x| x.wrapping_mul(24).wrapping_add(58)).map(|x| x.wrapping_mul(25).wrapping_add(58)).map(|x| x.wrapping_mul(26).wrapping_add(58)).map(|x| x.wrapping_mul(27).wrapping_add(58)).map(|x| x.wrapping_mul(28).wrapping_add(58)).map(|x| x.wrapping_mul(29).wrapping_add(58)).map(|x| x.wrapping_mul(30).wrapping_add(58)).map(|x| x.wrapping_mul(31).wrapping_add(58)).map(|x| x.wrapping_mul(32).wrapping_add(58)).map(|x| x.wrapping_mul(33).wrapping_add(58)).map(|x| x.wrapping_mul(34).wrapping_add(58)).map(|x| x.wrapping_mul(35).wrapping_add(58)).map(|x| x.wrapping_mul(36).wrapping_add(58)).map(|x| x.wrapping_mul(37).wrapping_add(58)).map(|x| x.wrapping_mul(38).wrapping_add(58)).map(|x| x.wrapping_mul(39).wrapping_add(58)).map(|x| x.wrapping_mul(40).wrapping_add(58)).map(|x| x.wrapping_mul(41).wrapping_add(58)).map(|x| x.wrapping_mul(42).wrapping_add(58)).fold(0, u64::wrapping_add) } +pub fn busy_59() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(59)).map(|x| x.wrapping_mul(4).wrapping_add(59)).map(|x| x.wrapping_mul(5).wrapping_add(59)).map(|x| x.wrapping_mul(6).wrapping_add(59)).map(|x| x.wrapping_mul(7).wrapping_add(59)).map(|x| x.wrapping_mul(8).wrapping_add(59)).map(|x| x.wrapping_mul(9).wrapping_add(59)).map(|x| x.wrapping_mul(10).wrapping_add(59)).map(|x| x.wrapping_mul(11).wrapping_add(59)).map(|x| x.wrapping_mul(12).wrapping_add(59)).map(|x| x.wrapping_mul(13).wrapping_add(59)).map(|x| x.wrapping_mul(14).wrapping_add(59)).map(|x| x.wrapping_mul(15).wrapping_add(59)).map(|x| x.wrapping_mul(16).wrapping_add(59)).map(|x| x.wrapping_mul(17).wrapping_add(59)).map(|x| x.wrapping_mul(18).wrapping_add(59)).map(|x| x.wrapping_mul(19).wrapping_add(59)).map(|x| x.wrapping_mul(20).wrapping_add(59)).map(|x| x.wrapping_mul(21).wrapping_add(59)).map(|x| x.wrapping_mul(22).wrapping_add(59)).map(|x| x.wrapping_mul(23).wrapping_add(59)).map(|x| x.wrapping_mul(24).wrapping_add(59)).map(|x| x.wrapping_mul(25).wrapping_add(59)).map(|x| x.wrapping_mul(26).wrapping_add(59)).map(|x| x.wrapping_mul(27).wrapping_add(59)).map(|x| x.wrapping_mul(28).wrapping_add(59)).map(|x| x.wrapping_mul(29).wrapping_add(59)).map(|x| x.wrapping_mul(30).wrapping_add(59)).map(|x| x.wrapping_mul(31).wrapping_add(59)).map(|x| x.wrapping_mul(32).wrapping_add(59)).map(|x| x.wrapping_mul(33).wrapping_add(59)).map(|x| x.wrapping_mul(34).wrapping_add(59)).map(|x| x.wrapping_mul(35).wrapping_add(59)).map(|x| x.wrapping_mul(36).wrapping_add(59)).map(|x| x.wrapping_mul(37).wrapping_add(59)).map(|x| x.wrapping_mul(38).wrapping_add(59)).map(|x| x.wrapping_mul(39).wrapping_add(59)).map(|x| x.wrapping_mul(40).wrapping_add(59)).map(|x| x.wrapping_mul(41).wrapping_add(59)).map(|x| x.wrapping_mul(42).wrapping_add(59)).fold(0, u64::wrapping_add) } +pub fn busy_60() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(60)).map(|x| x.wrapping_mul(4).wrapping_add(60)).map(|x| x.wrapping_mul(5).wrapping_add(60)).map(|x| x.wrapping_mul(6).wrapping_add(60)).map(|x| x.wrapping_mul(7).wrapping_add(60)).map(|x| x.wrapping_mul(8).wrapping_add(60)).map(|x| x.wrapping_mul(9).wrapping_add(60)).map(|x| x.wrapping_mul(10).wrapping_add(60)).map(|x| x.wrapping_mul(11).wrapping_add(60)).map(|x| x.wrapping_mul(12).wrapping_add(60)).map(|x| x.wrapping_mul(13).wrapping_add(60)).map(|x| x.wrapping_mul(14).wrapping_add(60)).map(|x| x.wrapping_mul(15).wrapping_add(60)).map(|x| x.wrapping_mul(16).wrapping_add(60)).map(|x| x.wrapping_mul(17).wrapping_add(60)).map(|x| x.wrapping_mul(18).wrapping_add(60)).map(|x| x.wrapping_mul(19).wrapping_add(60)).map(|x| x.wrapping_mul(20).wrapping_add(60)).map(|x| x.wrapping_mul(21).wrapping_add(60)).map(|x| x.wrapping_mul(22).wrapping_add(60)).map(|x| x.wrapping_mul(23).wrapping_add(60)).map(|x| x.wrapping_mul(24).wrapping_add(60)).map(|x| x.wrapping_mul(25).wrapping_add(60)).map(|x| x.wrapping_mul(26).wrapping_add(60)).map(|x| x.wrapping_mul(27).wrapping_add(60)).map(|x| x.wrapping_mul(28).wrapping_add(60)).map(|x| x.wrapping_mul(29).wrapping_add(60)).map(|x| x.wrapping_mul(30).wrapping_add(60)).map(|x| x.wrapping_mul(31).wrapping_add(60)).map(|x| x.wrapping_mul(32).wrapping_add(60)).map(|x| x.wrapping_mul(33).wrapping_add(60)).map(|x| x.wrapping_mul(34).wrapping_add(60)).map(|x| x.wrapping_mul(35).wrapping_add(60)).map(|x| x.wrapping_mul(36).wrapping_add(60)).map(|x| x.wrapping_mul(37).wrapping_add(60)).map(|x| x.wrapping_mul(38).wrapping_add(60)).map(|x| x.wrapping_mul(39).wrapping_add(60)).map(|x| x.wrapping_mul(40).wrapping_add(60)).map(|x| x.wrapping_mul(41).wrapping_add(60)).map(|x| x.wrapping_mul(42).wrapping_add(60)).fold(0, u64::wrapping_add) } +pub fn busy_61() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(61)).map(|x| x.wrapping_mul(4).wrapping_add(61)).map(|x| x.wrapping_mul(5).wrapping_add(61)).map(|x| x.wrapping_mul(6).wrapping_add(61)).map(|x| x.wrapping_mul(7).wrapping_add(61)).map(|x| x.wrapping_mul(8).wrapping_add(61)).map(|x| x.wrapping_mul(9).wrapping_add(61)).map(|x| x.wrapping_mul(10).wrapping_add(61)).map(|x| x.wrapping_mul(11).wrapping_add(61)).map(|x| x.wrapping_mul(12).wrapping_add(61)).map(|x| x.wrapping_mul(13).wrapping_add(61)).map(|x| x.wrapping_mul(14).wrapping_add(61)).map(|x| x.wrapping_mul(15).wrapping_add(61)).map(|x| x.wrapping_mul(16).wrapping_add(61)).map(|x| x.wrapping_mul(17).wrapping_add(61)).map(|x| x.wrapping_mul(18).wrapping_add(61)).map(|x| x.wrapping_mul(19).wrapping_add(61)).map(|x| x.wrapping_mul(20).wrapping_add(61)).map(|x| x.wrapping_mul(21).wrapping_add(61)).map(|x| x.wrapping_mul(22).wrapping_add(61)).map(|x| x.wrapping_mul(23).wrapping_add(61)).map(|x| x.wrapping_mul(24).wrapping_add(61)).map(|x| x.wrapping_mul(25).wrapping_add(61)).map(|x| x.wrapping_mul(26).wrapping_add(61)).map(|x| x.wrapping_mul(27).wrapping_add(61)).map(|x| x.wrapping_mul(28).wrapping_add(61)).map(|x| x.wrapping_mul(29).wrapping_add(61)).map(|x| x.wrapping_mul(30).wrapping_add(61)).map(|x| x.wrapping_mul(31).wrapping_add(61)).map(|x| x.wrapping_mul(32).wrapping_add(61)).map(|x| x.wrapping_mul(33).wrapping_add(61)).map(|x| x.wrapping_mul(34).wrapping_add(61)).map(|x| x.wrapping_mul(35).wrapping_add(61)).map(|x| x.wrapping_mul(36).wrapping_add(61)).map(|x| x.wrapping_mul(37).wrapping_add(61)).map(|x| x.wrapping_mul(38).wrapping_add(61)).map(|x| x.wrapping_mul(39).wrapping_add(61)).map(|x| x.wrapping_mul(40).wrapping_add(61)).map(|x| x.wrapping_mul(41).wrapping_add(61)).map(|x| x.wrapping_mul(42).wrapping_add(61)).fold(0, u64::wrapping_add) } +pub fn busy_62() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(62)).map(|x| x.wrapping_mul(4).wrapping_add(62)).map(|x| x.wrapping_mul(5).wrapping_add(62)).map(|x| x.wrapping_mul(6).wrapping_add(62)).map(|x| x.wrapping_mul(7).wrapping_add(62)).map(|x| x.wrapping_mul(8).wrapping_add(62)).map(|x| x.wrapping_mul(9).wrapping_add(62)).map(|x| x.wrapping_mul(10).wrapping_add(62)).map(|x| x.wrapping_mul(11).wrapping_add(62)).map(|x| x.wrapping_mul(12).wrapping_add(62)).map(|x| x.wrapping_mul(13).wrapping_add(62)).map(|x| x.wrapping_mul(14).wrapping_add(62)).map(|x| x.wrapping_mul(15).wrapping_add(62)).map(|x| x.wrapping_mul(16).wrapping_add(62)).map(|x| x.wrapping_mul(17).wrapping_add(62)).map(|x| x.wrapping_mul(18).wrapping_add(62)).map(|x| x.wrapping_mul(19).wrapping_add(62)).map(|x| x.wrapping_mul(20).wrapping_add(62)).map(|x| x.wrapping_mul(21).wrapping_add(62)).map(|x| x.wrapping_mul(22).wrapping_add(62)).map(|x| x.wrapping_mul(23).wrapping_add(62)).map(|x| x.wrapping_mul(24).wrapping_add(62)).map(|x| x.wrapping_mul(25).wrapping_add(62)).map(|x| x.wrapping_mul(26).wrapping_add(62)).map(|x| x.wrapping_mul(27).wrapping_add(62)).map(|x| x.wrapping_mul(28).wrapping_add(62)).map(|x| x.wrapping_mul(29).wrapping_add(62)).map(|x| x.wrapping_mul(30).wrapping_add(62)).map(|x| x.wrapping_mul(31).wrapping_add(62)).map(|x| x.wrapping_mul(32).wrapping_add(62)).map(|x| x.wrapping_mul(33).wrapping_add(62)).map(|x| x.wrapping_mul(34).wrapping_add(62)).map(|x| x.wrapping_mul(35).wrapping_add(62)).map(|x| x.wrapping_mul(36).wrapping_add(62)).map(|x| x.wrapping_mul(37).wrapping_add(62)).map(|x| x.wrapping_mul(38).wrapping_add(62)).map(|x| x.wrapping_mul(39).wrapping_add(62)).map(|x| x.wrapping_mul(40).wrapping_add(62)).map(|x| x.wrapping_mul(41).wrapping_add(62)).map(|x| x.wrapping_mul(42).wrapping_add(62)).fold(0, u64::wrapping_add) } +pub fn busy_63() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(63)).map(|x| x.wrapping_mul(4).wrapping_add(63)).map(|x| x.wrapping_mul(5).wrapping_add(63)).map(|x| x.wrapping_mul(6).wrapping_add(63)).map(|x| x.wrapping_mul(7).wrapping_add(63)).map(|x| x.wrapping_mul(8).wrapping_add(63)).map(|x| x.wrapping_mul(9).wrapping_add(63)).map(|x| x.wrapping_mul(10).wrapping_add(63)).map(|x| x.wrapping_mul(11).wrapping_add(63)).map(|x| x.wrapping_mul(12).wrapping_add(63)).map(|x| x.wrapping_mul(13).wrapping_add(63)).map(|x| x.wrapping_mul(14).wrapping_add(63)).map(|x| x.wrapping_mul(15).wrapping_add(63)).map(|x| x.wrapping_mul(16).wrapping_add(63)).map(|x| x.wrapping_mul(17).wrapping_add(63)).map(|x| x.wrapping_mul(18).wrapping_add(63)).map(|x| x.wrapping_mul(19).wrapping_add(63)).map(|x| x.wrapping_mul(20).wrapping_add(63)).map(|x| x.wrapping_mul(21).wrapping_add(63)).map(|x| x.wrapping_mul(22).wrapping_add(63)).map(|x| x.wrapping_mul(23).wrapping_add(63)).map(|x| x.wrapping_mul(24).wrapping_add(63)).map(|x| x.wrapping_mul(25).wrapping_add(63)).map(|x| x.wrapping_mul(26).wrapping_add(63)).map(|x| x.wrapping_mul(27).wrapping_add(63)).map(|x| x.wrapping_mul(28).wrapping_add(63)).map(|x| x.wrapping_mul(29).wrapping_add(63)).map(|x| x.wrapping_mul(30).wrapping_add(63)).map(|x| x.wrapping_mul(31).wrapping_add(63)).map(|x| x.wrapping_mul(32).wrapping_add(63)).map(|x| x.wrapping_mul(33).wrapping_add(63)).map(|x| x.wrapping_mul(34).wrapping_add(63)).map(|x| x.wrapping_mul(35).wrapping_add(63)).map(|x| x.wrapping_mul(36).wrapping_add(63)).map(|x| x.wrapping_mul(37).wrapping_add(63)).map(|x| x.wrapping_mul(38).wrapping_add(63)).map(|x| x.wrapping_mul(39).wrapping_add(63)).map(|x| x.wrapping_mul(40).wrapping_add(63)).map(|x| x.wrapping_mul(41).wrapping_add(63)).map(|x| x.wrapping_mul(42).wrapping_add(63)).fold(0, u64::wrapping_add) } +pub fn busy_64() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(64)).map(|x| x.wrapping_mul(4).wrapping_add(64)).map(|x| x.wrapping_mul(5).wrapping_add(64)).map(|x| x.wrapping_mul(6).wrapping_add(64)).map(|x| x.wrapping_mul(7).wrapping_add(64)).map(|x| x.wrapping_mul(8).wrapping_add(64)).map(|x| x.wrapping_mul(9).wrapping_add(64)).map(|x| x.wrapping_mul(10).wrapping_add(64)).map(|x| x.wrapping_mul(11).wrapping_add(64)).map(|x| x.wrapping_mul(12).wrapping_add(64)).map(|x| x.wrapping_mul(13).wrapping_add(64)).map(|x| x.wrapping_mul(14).wrapping_add(64)).map(|x| x.wrapping_mul(15).wrapping_add(64)).map(|x| x.wrapping_mul(16).wrapping_add(64)).map(|x| x.wrapping_mul(17).wrapping_add(64)).map(|x| x.wrapping_mul(18).wrapping_add(64)).map(|x| x.wrapping_mul(19).wrapping_add(64)).map(|x| x.wrapping_mul(20).wrapping_add(64)).map(|x| x.wrapping_mul(21).wrapping_add(64)).map(|x| x.wrapping_mul(22).wrapping_add(64)).map(|x| x.wrapping_mul(23).wrapping_add(64)).map(|x| x.wrapping_mul(24).wrapping_add(64)).map(|x| x.wrapping_mul(25).wrapping_add(64)).map(|x| x.wrapping_mul(26).wrapping_add(64)).map(|x| x.wrapping_mul(27).wrapping_add(64)).map(|x| x.wrapping_mul(28).wrapping_add(64)).map(|x| x.wrapping_mul(29).wrapping_add(64)).map(|x| x.wrapping_mul(30).wrapping_add(64)).map(|x| x.wrapping_mul(31).wrapping_add(64)).map(|x| x.wrapping_mul(32).wrapping_add(64)).map(|x| x.wrapping_mul(33).wrapping_add(64)).map(|x| x.wrapping_mul(34).wrapping_add(64)).map(|x| x.wrapping_mul(35).wrapping_add(64)).map(|x| x.wrapping_mul(36).wrapping_add(64)).map(|x| x.wrapping_mul(37).wrapping_add(64)).map(|x| x.wrapping_mul(38).wrapping_add(64)).map(|x| x.wrapping_mul(39).wrapping_add(64)).map(|x| x.wrapping_mul(40).wrapping_add(64)).map(|x| x.wrapping_mul(41).wrapping_add(64)).map(|x| x.wrapping_mul(42).wrapping_add(64)).fold(0, u64::wrapping_add) } +pub fn busy_65() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(65)).map(|x| x.wrapping_mul(4).wrapping_add(65)).map(|x| x.wrapping_mul(5).wrapping_add(65)).map(|x| x.wrapping_mul(6).wrapping_add(65)).map(|x| x.wrapping_mul(7).wrapping_add(65)).map(|x| x.wrapping_mul(8).wrapping_add(65)).map(|x| x.wrapping_mul(9).wrapping_add(65)).map(|x| x.wrapping_mul(10).wrapping_add(65)).map(|x| x.wrapping_mul(11).wrapping_add(65)).map(|x| x.wrapping_mul(12).wrapping_add(65)).map(|x| x.wrapping_mul(13).wrapping_add(65)).map(|x| x.wrapping_mul(14).wrapping_add(65)).map(|x| x.wrapping_mul(15).wrapping_add(65)).map(|x| x.wrapping_mul(16).wrapping_add(65)).map(|x| x.wrapping_mul(17).wrapping_add(65)).map(|x| x.wrapping_mul(18).wrapping_add(65)).map(|x| x.wrapping_mul(19).wrapping_add(65)).map(|x| x.wrapping_mul(20).wrapping_add(65)).map(|x| x.wrapping_mul(21).wrapping_add(65)).map(|x| x.wrapping_mul(22).wrapping_add(65)).map(|x| x.wrapping_mul(23).wrapping_add(65)).map(|x| x.wrapping_mul(24).wrapping_add(65)).map(|x| x.wrapping_mul(25).wrapping_add(65)).map(|x| x.wrapping_mul(26).wrapping_add(65)).map(|x| x.wrapping_mul(27).wrapping_add(65)).map(|x| x.wrapping_mul(28).wrapping_add(65)).map(|x| x.wrapping_mul(29).wrapping_add(65)).map(|x| x.wrapping_mul(30).wrapping_add(65)).map(|x| x.wrapping_mul(31).wrapping_add(65)).map(|x| x.wrapping_mul(32).wrapping_add(65)).map(|x| x.wrapping_mul(33).wrapping_add(65)).map(|x| x.wrapping_mul(34).wrapping_add(65)).map(|x| x.wrapping_mul(35).wrapping_add(65)).map(|x| x.wrapping_mul(36).wrapping_add(65)).map(|x| x.wrapping_mul(37).wrapping_add(65)).map(|x| x.wrapping_mul(38).wrapping_add(65)).map(|x| x.wrapping_mul(39).wrapping_add(65)).map(|x| x.wrapping_mul(40).wrapping_add(65)).map(|x| x.wrapping_mul(41).wrapping_add(65)).map(|x| x.wrapping_mul(42).wrapping_add(65)).fold(0, u64::wrapping_add) } +pub fn busy_66() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(66)).map(|x| x.wrapping_mul(4).wrapping_add(66)).map(|x| x.wrapping_mul(5).wrapping_add(66)).map(|x| x.wrapping_mul(6).wrapping_add(66)).map(|x| x.wrapping_mul(7).wrapping_add(66)).map(|x| x.wrapping_mul(8).wrapping_add(66)).map(|x| x.wrapping_mul(9).wrapping_add(66)).map(|x| x.wrapping_mul(10).wrapping_add(66)).map(|x| x.wrapping_mul(11).wrapping_add(66)).map(|x| x.wrapping_mul(12).wrapping_add(66)).map(|x| x.wrapping_mul(13).wrapping_add(66)).map(|x| x.wrapping_mul(14).wrapping_add(66)).map(|x| x.wrapping_mul(15).wrapping_add(66)).map(|x| x.wrapping_mul(16).wrapping_add(66)).map(|x| x.wrapping_mul(17).wrapping_add(66)).map(|x| x.wrapping_mul(18).wrapping_add(66)).map(|x| x.wrapping_mul(19).wrapping_add(66)).map(|x| x.wrapping_mul(20).wrapping_add(66)).map(|x| x.wrapping_mul(21).wrapping_add(66)).map(|x| x.wrapping_mul(22).wrapping_add(66)).map(|x| x.wrapping_mul(23).wrapping_add(66)).map(|x| x.wrapping_mul(24).wrapping_add(66)).map(|x| x.wrapping_mul(25).wrapping_add(66)).map(|x| x.wrapping_mul(26).wrapping_add(66)).map(|x| x.wrapping_mul(27).wrapping_add(66)).map(|x| x.wrapping_mul(28).wrapping_add(66)).map(|x| x.wrapping_mul(29).wrapping_add(66)).map(|x| x.wrapping_mul(30).wrapping_add(66)).map(|x| x.wrapping_mul(31).wrapping_add(66)).map(|x| x.wrapping_mul(32).wrapping_add(66)).map(|x| x.wrapping_mul(33).wrapping_add(66)).map(|x| x.wrapping_mul(34).wrapping_add(66)).map(|x| x.wrapping_mul(35).wrapping_add(66)).map(|x| x.wrapping_mul(36).wrapping_add(66)).map(|x| x.wrapping_mul(37).wrapping_add(66)).map(|x| x.wrapping_mul(38).wrapping_add(66)).map(|x| x.wrapping_mul(39).wrapping_add(66)).map(|x| x.wrapping_mul(40).wrapping_add(66)).map(|x| x.wrapping_mul(41).wrapping_add(66)).map(|x| x.wrapping_mul(42).wrapping_add(66)).fold(0, u64::wrapping_add) } +pub fn busy_67() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(67)).map(|x| x.wrapping_mul(4).wrapping_add(67)).map(|x| x.wrapping_mul(5).wrapping_add(67)).map(|x| x.wrapping_mul(6).wrapping_add(67)).map(|x| x.wrapping_mul(7).wrapping_add(67)).map(|x| x.wrapping_mul(8).wrapping_add(67)).map(|x| x.wrapping_mul(9).wrapping_add(67)).map(|x| x.wrapping_mul(10).wrapping_add(67)).map(|x| x.wrapping_mul(11).wrapping_add(67)).map(|x| x.wrapping_mul(12).wrapping_add(67)).map(|x| x.wrapping_mul(13).wrapping_add(67)).map(|x| x.wrapping_mul(14).wrapping_add(67)).map(|x| x.wrapping_mul(15).wrapping_add(67)).map(|x| x.wrapping_mul(16).wrapping_add(67)).map(|x| x.wrapping_mul(17).wrapping_add(67)).map(|x| x.wrapping_mul(18).wrapping_add(67)).map(|x| x.wrapping_mul(19).wrapping_add(67)).map(|x| x.wrapping_mul(20).wrapping_add(67)).map(|x| x.wrapping_mul(21).wrapping_add(67)).map(|x| x.wrapping_mul(22).wrapping_add(67)).map(|x| x.wrapping_mul(23).wrapping_add(67)).map(|x| x.wrapping_mul(24).wrapping_add(67)).map(|x| x.wrapping_mul(25).wrapping_add(67)).map(|x| x.wrapping_mul(26).wrapping_add(67)).map(|x| x.wrapping_mul(27).wrapping_add(67)).map(|x| x.wrapping_mul(28).wrapping_add(67)).map(|x| x.wrapping_mul(29).wrapping_add(67)).map(|x| x.wrapping_mul(30).wrapping_add(67)).map(|x| x.wrapping_mul(31).wrapping_add(67)).map(|x| x.wrapping_mul(32).wrapping_add(67)).map(|x| x.wrapping_mul(33).wrapping_add(67)).map(|x| x.wrapping_mul(34).wrapping_add(67)).map(|x| x.wrapping_mul(35).wrapping_add(67)).map(|x| x.wrapping_mul(36).wrapping_add(67)).map(|x| x.wrapping_mul(37).wrapping_add(67)).map(|x| x.wrapping_mul(38).wrapping_add(67)).map(|x| x.wrapping_mul(39).wrapping_add(67)).map(|x| x.wrapping_mul(40).wrapping_add(67)).map(|x| x.wrapping_mul(41).wrapping_add(67)).map(|x| x.wrapping_mul(42).wrapping_add(67)).fold(0, u64::wrapping_add) } +pub fn busy_68() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(68)).map(|x| x.wrapping_mul(4).wrapping_add(68)).map(|x| x.wrapping_mul(5).wrapping_add(68)).map(|x| x.wrapping_mul(6).wrapping_add(68)).map(|x| x.wrapping_mul(7).wrapping_add(68)).map(|x| x.wrapping_mul(8).wrapping_add(68)).map(|x| x.wrapping_mul(9).wrapping_add(68)).map(|x| x.wrapping_mul(10).wrapping_add(68)).map(|x| x.wrapping_mul(11).wrapping_add(68)).map(|x| x.wrapping_mul(12).wrapping_add(68)).map(|x| x.wrapping_mul(13).wrapping_add(68)).map(|x| x.wrapping_mul(14).wrapping_add(68)).map(|x| x.wrapping_mul(15).wrapping_add(68)).map(|x| x.wrapping_mul(16).wrapping_add(68)).map(|x| x.wrapping_mul(17).wrapping_add(68)).map(|x| x.wrapping_mul(18).wrapping_add(68)).map(|x| x.wrapping_mul(19).wrapping_add(68)).map(|x| x.wrapping_mul(20).wrapping_add(68)).map(|x| x.wrapping_mul(21).wrapping_add(68)).map(|x| x.wrapping_mul(22).wrapping_add(68)).map(|x| x.wrapping_mul(23).wrapping_add(68)).map(|x| x.wrapping_mul(24).wrapping_add(68)).map(|x| x.wrapping_mul(25).wrapping_add(68)).map(|x| x.wrapping_mul(26).wrapping_add(68)).map(|x| x.wrapping_mul(27).wrapping_add(68)).map(|x| x.wrapping_mul(28).wrapping_add(68)).map(|x| x.wrapping_mul(29).wrapping_add(68)).map(|x| x.wrapping_mul(30).wrapping_add(68)).map(|x| x.wrapping_mul(31).wrapping_add(68)).map(|x| x.wrapping_mul(32).wrapping_add(68)).map(|x| x.wrapping_mul(33).wrapping_add(68)).map(|x| x.wrapping_mul(34).wrapping_add(68)).map(|x| x.wrapping_mul(35).wrapping_add(68)).map(|x| x.wrapping_mul(36).wrapping_add(68)).map(|x| x.wrapping_mul(37).wrapping_add(68)).map(|x| x.wrapping_mul(38).wrapping_add(68)).map(|x| x.wrapping_mul(39).wrapping_add(68)).map(|x| x.wrapping_mul(40).wrapping_add(68)).map(|x| x.wrapping_mul(41).wrapping_add(68)).map(|x| x.wrapping_mul(42).wrapping_add(68)).fold(0, u64::wrapping_add) } +pub fn busy_69() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(69)).map(|x| x.wrapping_mul(4).wrapping_add(69)).map(|x| x.wrapping_mul(5).wrapping_add(69)).map(|x| x.wrapping_mul(6).wrapping_add(69)).map(|x| x.wrapping_mul(7).wrapping_add(69)).map(|x| x.wrapping_mul(8).wrapping_add(69)).map(|x| x.wrapping_mul(9).wrapping_add(69)).map(|x| x.wrapping_mul(10).wrapping_add(69)).map(|x| x.wrapping_mul(11).wrapping_add(69)).map(|x| x.wrapping_mul(12).wrapping_add(69)).map(|x| x.wrapping_mul(13).wrapping_add(69)).map(|x| x.wrapping_mul(14).wrapping_add(69)).map(|x| x.wrapping_mul(15).wrapping_add(69)).map(|x| x.wrapping_mul(16).wrapping_add(69)).map(|x| x.wrapping_mul(17).wrapping_add(69)).map(|x| x.wrapping_mul(18).wrapping_add(69)).map(|x| x.wrapping_mul(19).wrapping_add(69)).map(|x| x.wrapping_mul(20).wrapping_add(69)).map(|x| x.wrapping_mul(21).wrapping_add(69)).map(|x| x.wrapping_mul(22).wrapping_add(69)).map(|x| x.wrapping_mul(23).wrapping_add(69)).map(|x| x.wrapping_mul(24).wrapping_add(69)).map(|x| x.wrapping_mul(25).wrapping_add(69)).map(|x| x.wrapping_mul(26).wrapping_add(69)).map(|x| x.wrapping_mul(27).wrapping_add(69)).map(|x| x.wrapping_mul(28).wrapping_add(69)).map(|x| x.wrapping_mul(29).wrapping_add(69)).map(|x| x.wrapping_mul(30).wrapping_add(69)).map(|x| x.wrapping_mul(31).wrapping_add(69)).map(|x| x.wrapping_mul(32).wrapping_add(69)).map(|x| x.wrapping_mul(33).wrapping_add(69)).map(|x| x.wrapping_mul(34).wrapping_add(69)).map(|x| x.wrapping_mul(35).wrapping_add(69)).map(|x| x.wrapping_mul(36).wrapping_add(69)).map(|x| x.wrapping_mul(37).wrapping_add(69)).map(|x| x.wrapping_mul(38).wrapping_add(69)).map(|x| x.wrapping_mul(39).wrapping_add(69)).map(|x| x.wrapping_mul(40).wrapping_add(69)).map(|x| x.wrapping_mul(41).wrapping_add(69)).map(|x| x.wrapping_mul(42).wrapping_add(69)).fold(0, u64::wrapping_add) } +pub fn busy_70() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(70)).map(|x| x.wrapping_mul(4).wrapping_add(70)).map(|x| x.wrapping_mul(5).wrapping_add(70)).map(|x| x.wrapping_mul(6).wrapping_add(70)).map(|x| x.wrapping_mul(7).wrapping_add(70)).map(|x| x.wrapping_mul(8).wrapping_add(70)).map(|x| x.wrapping_mul(9).wrapping_add(70)).map(|x| x.wrapping_mul(10).wrapping_add(70)).map(|x| x.wrapping_mul(11).wrapping_add(70)).map(|x| x.wrapping_mul(12).wrapping_add(70)).map(|x| x.wrapping_mul(13).wrapping_add(70)).map(|x| x.wrapping_mul(14).wrapping_add(70)).map(|x| x.wrapping_mul(15).wrapping_add(70)).map(|x| x.wrapping_mul(16).wrapping_add(70)).map(|x| x.wrapping_mul(17).wrapping_add(70)).map(|x| x.wrapping_mul(18).wrapping_add(70)).map(|x| x.wrapping_mul(19).wrapping_add(70)).map(|x| x.wrapping_mul(20).wrapping_add(70)).map(|x| x.wrapping_mul(21).wrapping_add(70)).map(|x| x.wrapping_mul(22).wrapping_add(70)).map(|x| x.wrapping_mul(23).wrapping_add(70)).map(|x| x.wrapping_mul(24).wrapping_add(70)).map(|x| x.wrapping_mul(25).wrapping_add(70)).map(|x| x.wrapping_mul(26).wrapping_add(70)).map(|x| x.wrapping_mul(27).wrapping_add(70)).map(|x| x.wrapping_mul(28).wrapping_add(70)).map(|x| x.wrapping_mul(29).wrapping_add(70)).map(|x| x.wrapping_mul(30).wrapping_add(70)).map(|x| x.wrapping_mul(31).wrapping_add(70)).map(|x| x.wrapping_mul(32).wrapping_add(70)).map(|x| x.wrapping_mul(33).wrapping_add(70)).map(|x| x.wrapping_mul(34).wrapping_add(70)).map(|x| x.wrapping_mul(35).wrapping_add(70)).map(|x| x.wrapping_mul(36).wrapping_add(70)).map(|x| x.wrapping_mul(37).wrapping_add(70)).map(|x| x.wrapping_mul(38).wrapping_add(70)).map(|x| x.wrapping_mul(39).wrapping_add(70)).map(|x| x.wrapping_mul(40).wrapping_add(70)).map(|x| x.wrapping_mul(41).wrapping_add(70)).map(|x| x.wrapping_mul(42).wrapping_add(70)).fold(0, u64::wrapping_add) } +pub fn busy_71() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(71)).map(|x| x.wrapping_mul(4).wrapping_add(71)).map(|x| x.wrapping_mul(5).wrapping_add(71)).map(|x| x.wrapping_mul(6).wrapping_add(71)).map(|x| x.wrapping_mul(7).wrapping_add(71)).map(|x| x.wrapping_mul(8).wrapping_add(71)).map(|x| x.wrapping_mul(9).wrapping_add(71)).map(|x| x.wrapping_mul(10).wrapping_add(71)).map(|x| x.wrapping_mul(11).wrapping_add(71)).map(|x| x.wrapping_mul(12).wrapping_add(71)).map(|x| x.wrapping_mul(13).wrapping_add(71)).map(|x| x.wrapping_mul(14).wrapping_add(71)).map(|x| x.wrapping_mul(15).wrapping_add(71)).map(|x| x.wrapping_mul(16).wrapping_add(71)).map(|x| x.wrapping_mul(17).wrapping_add(71)).map(|x| x.wrapping_mul(18).wrapping_add(71)).map(|x| x.wrapping_mul(19).wrapping_add(71)).map(|x| x.wrapping_mul(20).wrapping_add(71)).map(|x| x.wrapping_mul(21).wrapping_add(71)).map(|x| x.wrapping_mul(22).wrapping_add(71)).map(|x| x.wrapping_mul(23).wrapping_add(71)).map(|x| x.wrapping_mul(24).wrapping_add(71)).map(|x| x.wrapping_mul(25).wrapping_add(71)).map(|x| x.wrapping_mul(26).wrapping_add(71)).map(|x| x.wrapping_mul(27).wrapping_add(71)).map(|x| x.wrapping_mul(28).wrapping_add(71)).map(|x| x.wrapping_mul(29).wrapping_add(71)).map(|x| x.wrapping_mul(30).wrapping_add(71)).map(|x| x.wrapping_mul(31).wrapping_add(71)).map(|x| x.wrapping_mul(32).wrapping_add(71)).map(|x| x.wrapping_mul(33).wrapping_add(71)).map(|x| x.wrapping_mul(34).wrapping_add(71)).map(|x| x.wrapping_mul(35).wrapping_add(71)).map(|x| x.wrapping_mul(36).wrapping_add(71)).map(|x| x.wrapping_mul(37).wrapping_add(71)).map(|x| x.wrapping_mul(38).wrapping_add(71)).map(|x| x.wrapping_mul(39).wrapping_add(71)).map(|x| x.wrapping_mul(40).wrapping_add(71)).map(|x| x.wrapping_mul(41).wrapping_add(71)).map(|x| x.wrapping_mul(42).wrapping_add(71)).fold(0, u64::wrapping_add) } +pub fn busy_72() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(72)).map(|x| x.wrapping_mul(4).wrapping_add(72)).map(|x| x.wrapping_mul(5).wrapping_add(72)).map(|x| x.wrapping_mul(6).wrapping_add(72)).map(|x| x.wrapping_mul(7).wrapping_add(72)).map(|x| x.wrapping_mul(8).wrapping_add(72)).map(|x| x.wrapping_mul(9).wrapping_add(72)).map(|x| x.wrapping_mul(10).wrapping_add(72)).map(|x| x.wrapping_mul(11).wrapping_add(72)).map(|x| x.wrapping_mul(12).wrapping_add(72)).map(|x| x.wrapping_mul(13).wrapping_add(72)).map(|x| x.wrapping_mul(14).wrapping_add(72)).map(|x| x.wrapping_mul(15).wrapping_add(72)).map(|x| x.wrapping_mul(16).wrapping_add(72)).map(|x| x.wrapping_mul(17).wrapping_add(72)).map(|x| x.wrapping_mul(18).wrapping_add(72)).map(|x| x.wrapping_mul(19).wrapping_add(72)).map(|x| x.wrapping_mul(20).wrapping_add(72)).map(|x| x.wrapping_mul(21).wrapping_add(72)).map(|x| x.wrapping_mul(22).wrapping_add(72)).map(|x| x.wrapping_mul(23).wrapping_add(72)).map(|x| x.wrapping_mul(24).wrapping_add(72)).map(|x| x.wrapping_mul(25).wrapping_add(72)).map(|x| x.wrapping_mul(26).wrapping_add(72)).map(|x| x.wrapping_mul(27).wrapping_add(72)).map(|x| x.wrapping_mul(28).wrapping_add(72)).map(|x| x.wrapping_mul(29).wrapping_add(72)).map(|x| x.wrapping_mul(30).wrapping_add(72)).map(|x| x.wrapping_mul(31).wrapping_add(72)).map(|x| x.wrapping_mul(32).wrapping_add(72)).map(|x| x.wrapping_mul(33).wrapping_add(72)).map(|x| x.wrapping_mul(34).wrapping_add(72)).map(|x| x.wrapping_mul(35).wrapping_add(72)).map(|x| x.wrapping_mul(36).wrapping_add(72)).map(|x| x.wrapping_mul(37).wrapping_add(72)).map(|x| x.wrapping_mul(38).wrapping_add(72)).map(|x| x.wrapping_mul(39).wrapping_add(72)).map(|x| x.wrapping_mul(40).wrapping_add(72)).map(|x| x.wrapping_mul(41).wrapping_add(72)).map(|x| x.wrapping_mul(42).wrapping_add(72)).fold(0, u64::wrapping_add) } +pub fn busy_73() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(73)).map(|x| x.wrapping_mul(4).wrapping_add(73)).map(|x| x.wrapping_mul(5).wrapping_add(73)).map(|x| x.wrapping_mul(6).wrapping_add(73)).map(|x| x.wrapping_mul(7).wrapping_add(73)).map(|x| x.wrapping_mul(8).wrapping_add(73)).map(|x| x.wrapping_mul(9).wrapping_add(73)).map(|x| x.wrapping_mul(10).wrapping_add(73)).map(|x| x.wrapping_mul(11).wrapping_add(73)).map(|x| x.wrapping_mul(12).wrapping_add(73)).map(|x| x.wrapping_mul(13).wrapping_add(73)).map(|x| x.wrapping_mul(14).wrapping_add(73)).map(|x| x.wrapping_mul(15).wrapping_add(73)).map(|x| x.wrapping_mul(16).wrapping_add(73)).map(|x| x.wrapping_mul(17).wrapping_add(73)).map(|x| x.wrapping_mul(18).wrapping_add(73)).map(|x| x.wrapping_mul(19).wrapping_add(73)).map(|x| x.wrapping_mul(20).wrapping_add(73)).map(|x| x.wrapping_mul(21).wrapping_add(73)).map(|x| x.wrapping_mul(22).wrapping_add(73)).map(|x| x.wrapping_mul(23).wrapping_add(73)).map(|x| x.wrapping_mul(24).wrapping_add(73)).map(|x| x.wrapping_mul(25).wrapping_add(73)).map(|x| x.wrapping_mul(26).wrapping_add(73)).map(|x| x.wrapping_mul(27).wrapping_add(73)).map(|x| x.wrapping_mul(28).wrapping_add(73)).map(|x| x.wrapping_mul(29).wrapping_add(73)).map(|x| x.wrapping_mul(30).wrapping_add(73)).map(|x| x.wrapping_mul(31).wrapping_add(73)).map(|x| x.wrapping_mul(32).wrapping_add(73)).map(|x| x.wrapping_mul(33).wrapping_add(73)).map(|x| x.wrapping_mul(34).wrapping_add(73)).map(|x| x.wrapping_mul(35).wrapping_add(73)).map(|x| x.wrapping_mul(36).wrapping_add(73)).map(|x| x.wrapping_mul(37).wrapping_add(73)).map(|x| x.wrapping_mul(38).wrapping_add(73)).map(|x| x.wrapping_mul(39).wrapping_add(73)).map(|x| x.wrapping_mul(40).wrapping_add(73)).map(|x| x.wrapping_mul(41).wrapping_add(73)).map(|x| x.wrapping_mul(42).wrapping_add(73)).fold(0, u64::wrapping_add) } +pub fn busy_74() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(74)).map(|x| x.wrapping_mul(4).wrapping_add(74)).map(|x| x.wrapping_mul(5).wrapping_add(74)).map(|x| x.wrapping_mul(6).wrapping_add(74)).map(|x| x.wrapping_mul(7).wrapping_add(74)).map(|x| x.wrapping_mul(8).wrapping_add(74)).map(|x| x.wrapping_mul(9).wrapping_add(74)).map(|x| x.wrapping_mul(10).wrapping_add(74)).map(|x| x.wrapping_mul(11).wrapping_add(74)).map(|x| x.wrapping_mul(12).wrapping_add(74)).map(|x| x.wrapping_mul(13).wrapping_add(74)).map(|x| x.wrapping_mul(14).wrapping_add(74)).map(|x| x.wrapping_mul(15).wrapping_add(74)).map(|x| x.wrapping_mul(16).wrapping_add(74)).map(|x| x.wrapping_mul(17).wrapping_add(74)).map(|x| x.wrapping_mul(18).wrapping_add(74)).map(|x| x.wrapping_mul(19).wrapping_add(74)).map(|x| x.wrapping_mul(20).wrapping_add(74)).map(|x| x.wrapping_mul(21).wrapping_add(74)).map(|x| x.wrapping_mul(22).wrapping_add(74)).map(|x| x.wrapping_mul(23).wrapping_add(74)).map(|x| x.wrapping_mul(24).wrapping_add(74)).map(|x| x.wrapping_mul(25).wrapping_add(74)).map(|x| x.wrapping_mul(26).wrapping_add(74)).map(|x| x.wrapping_mul(27).wrapping_add(74)).map(|x| x.wrapping_mul(28).wrapping_add(74)).map(|x| x.wrapping_mul(29).wrapping_add(74)).map(|x| x.wrapping_mul(30).wrapping_add(74)).map(|x| x.wrapping_mul(31).wrapping_add(74)).map(|x| x.wrapping_mul(32).wrapping_add(74)).map(|x| x.wrapping_mul(33).wrapping_add(74)).map(|x| x.wrapping_mul(34).wrapping_add(74)).map(|x| x.wrapping_mul(35).wrapping_add(74)).map(|x| x.wrapping_mul(36).wrapping_add(74)).map(|x| x.wrapping_mul(37).wrapping_add(74)).map(|x| x.wrapping_mul(38).wrapping_add(74)).map(|x| x.wrapping_mul(39).wrapping_add(74)).map(|x| x.wrapping_mul(40).wrapping_add(74)).map(|x| x.wrapping_mul(41).wrapping_add(74)).map(|x| x.wrapping_mul(42).wrapping_add(74)).fold(0, u64::wrapping_add) } +pub fn busy_75() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(75)).map(|x| x.wrapping_mul(4).wrapping_add(75)).map(|x| x.wrapping_mul(5).wrapping_add(75)).map(|x| x.wrapping_mul(6).wrapping_add(75)).map(|x| x.wrapping_mul(7).wrapping_add(75)).map(|x| x.wrapping_mul(8).wrapping_add(75)).map(|x| x.wrapping_mul(9).wrapping_add(75)).map(|x| x.wrapping_mul(10).wrapping_add(75)).map(|x| x.wrapping_mul(11).wrapping_add(75)).map(|x| x.wrapping_mul(12).wrapping_add(75)).map(|x| x.wrapping_mul(13).wrapping_add(75)).map(|x| x.wrapping_mul(14).wrapping_add(75)).map(|x| x.wrapping_mul(15).wrapping_add(75)).map(|x| x.wrapping_mul(16).wrapping_add(75)).map(|x| x.wrapping_mul(17).wrapping_add(75)).map(|x| x.wrapping_mul(18).wrapping_add(75)).map(|x| x.wrapping_mul(19).wrapping_add(75)).map(|x| x.wrapping_mul(20).wrapping_add(75)).map(|x| x.wrapping_mul(21).wrapping_add(75)).map(|x| x.wrapping_mul(22).wrapping_add(75)).map(|x| x.wrapping_mul(23).wrapping_add(75)).map(|x| x.wrapping_mul(24).wrapping_add(75)).map(|x| x.wrapping_mul(25).wrapping_add(75)).map(|x| x.wrapping_mul(26).wrapping_add(75)).map(|x| x.wrapping_mul(27).wrapping_add(75)).map(|x| x.wrapping_mul(28).wrapping_add(75)).map(|x| x.wrapping_mul(29).wrapping_add(75)).map(|x| x.wrapping_mul(30).wrapping_add(75)).map(|x| x.wrapping_mul(31).wrapping_add(75)).map(|x| x.wrapping_mul(32).wrapping_add(75)).map(|x| x.wrapping_mul(33).wrapping_add(75)).map(|x| x.wrapping_mul(34).wrapping_add(75)).map(|x| x.wrapping_mul(35).wrapping_add(75)).map(|x| x.wrapping_mul(36).wrapping_add(75)).map(|x| x.wrapping_mul(37).wrapping_add(75)).map(|x| x.wrapping_mul(38).wrapping_add(75)).map(|x| x.wrapping_mul(39).wrapping_add(75)).map(|x| x.wrapping_mul(40).wrapping_add(75)).map(|x| x.wrapping_mul(41).wrapping_add(75)).map(|x| x.wrapping_mul(42).wrapping_add(75)).fold(0, u64::wrapping_add) } +pub fn busy_76() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(76)).map(|x| x.wrapping_mul(4).wrapping_add(76)).map(|x| x.wrapping_mul(5).wrapping_add(76)).map(|x| x.wrapping_mul(6).wrapping_add(76)).map(|x| x.wrapping_mul(7).wrapping_add(76)).map(|x| x.wrapping_mul(8).wrapping_add(76)).map(|x| x.wrapping_mul(9).wrapping_add(76)).map(|x| x.wrapping_mul(10).wrapping_add(76)).map(|x| x.wrapping_mul(11).wrapping_add(76)).map(|x| x.wrapping_mul(12).wrapping_add(76)).map(|x| x.wrapping_mul(13).wrapping_add(76)).map(|x| x.wrapping_mul(14).wrapping_add(76)).map(|x| x.wrapping_mul(15).wrapping_add(76)).map(|x| x.wrapping_mul(16).wrapping_add(76)).map(|x| x.wrapping_mul(17).wrapping_add(76)).map(|x| x.wrapping_mul(18).wrapping_add(76)).map(|x| x.wrapping_mul(19).wrapping_add(76)).map(|x| x.wrapping_mul(20).wrapping_add(76)).map(|x| x.wrapping_mul(21).wrapping_add(76)).map(|x| x.wrapping_mul(22).wrapping_add(76)).map(|x| x.wrapping_mul(23).wrapping_add(76)).map(|x| x.wrapping_mul(24).wrapping_add(76)).map(|x| x.wrapping_mul(25).wrapping_add(76)).map(|x| x.wrapping_mul(26).wrapping_add(76)).map(|x| x.wrapping_mul(27).wrapping_add(76)).map(|x| x.wrapping_mul(28).wrapping_add(76)).map(|x| x.wrapping_mul(29).wrapping_add(76)).map(|x| x.wrapping_mul(30).wrapping_add(76)).map(|x| x.wrapping_mul(31).wrapping_add(76)).map(|x| x.wrapping_mul(32).wrapping_add(76)).map(|x| x.wrapping_mul(33).wrapping_add(76)).map(|x| x.wrapping_mul(34).wrapping_add(76)).map(|x| x.wrapping_mul(35).wrapping_add(76)).map(|x| x.wrapping_mul(36).wrapping_add(76)).map(|x| x.wrapping_mul(37).wrapping_add(76)).map(|x| x.wrapping_mul(38).wrapping_add(76)).map(|x| x.wrapping_mul(39).wrapping_add(76)).map(|x| x.wrapping_mul(40).wrapping_add(76)).map(|x| x.wrapping_mul(41).wrapping_add(76)).map(|x| x.wrapping_mul(42).wrapping_add(76)).fold(0, u64::wrapping_add) } +pub fn busy_77() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(77)).map(|x| x.wrapping_mul(4).wrapping_add(77)).map(|x| x.wrapping_mul(5).wrapping_add(77)).map(|x| x.wrapping_mul(6).wrapping_add(77)).map(|x| x.wrapping_mul(7).wrapping_add(77)).map(|x| x.wrapping_mul(8).wrapping_add(77)).map(|x| x.wrapping_mul(9).wrapping_add(77)).map(|x| x.wrapping_mul(10).wrapping_add(77)).map(|x| x.wrapping_mul(11).wrapping_add(77)).map(|x| x.wrapping_mul(12).wrapping_add(77)).map(|x| x.wrapping_mul(13).wrapping_add(77)).map(|x| x.wrapping_mul(14).wrapping_add(77)).map(|x| x.wrapping_mul(15).wrapping_add(77)).map(|x| x.wrapping_mul(16).wrapping_add(77)).map(|x| x.wrapping_mul(17).wrapping_add(77)).map(|x| x.wrapping_mul(18).wrapping_add(77)).map(|x| x.wrapping_mul(19).wrapping_add(77)).map(|x| x.wrapping_mul(20).wrapping_add(77)).map(|x| x.wrapping_mul(21).wrapping_add(77)).map(|x| x.wrapping_mul(22).wrapping_add(77)).map(|x| x.wrapping_mul(23).wrapping_add(77)).map(|x| x.wrapping_mul(24).wrapping_add(77)).map(|x| x.wrapping_mul(25).wrapping_add(77)).map(|x| x.wrapping_mul(26).wrapping_add(77)).map(|x| x.wrapping_mul(27).wrapping_add(77)).map(|x| x.wrapping_mul(28).wrapping_add(77)).map(|x| x.wrapping_mul(29).wrapping_add(77)).map(|x| x.wrapping_mul(30).wrapping_add(77)).map(|x| x.wrapping_mul(31).wrapping_add(77)).map(|x| x.wrapping_mul(32).wrapping_add(77)).map(|x| x.wrapping_mul(33).wrapping_add(77)).map(|x| x.wrapping_mul(34).wrapping_add(77)).map(|x| x.wrapping_mul(35).wrapping_add(77)).map(|x| x.wrapping_mul(36).wrapping_add(77)).map(|x| x.wrapping_mul(37).wrapping_add(77)).map(|x| x.wrapping_mul(38).wrapping_add(77)).map(|x| x.wrapping_mul(39).wrapping_add(77)).map(|x| x.wrapping_mul(40).wrapping_add(77)).map(|x| x.wrapping_mul(41).wrapping_add(77)).map(|x| x.wrapping_mul(42).wrapping_add(77)).fold(0, u64::wrapping_add) } +pub fn busy_78() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(78)).map(|x| x.wrapping_mul(4).wrapping_add(78)).map(|x| x.wrapping_mul(5).wrapping_add(78)).map(|x| x.wrapping_mul(6).wrapping_add(78)).map(|x| x.wrapping_mul(7).wrapping_add(78)).map(|x| x.wrapping_mul(8).wrapping_add(78)).map(|x| x.wrapping_mul(9).wrapping_add(78)).map(|x| x.wrapping_mul(10).wrapping_add(78)).map(|x| x.wrapping_mul(11).wrapping_add(78)).map(|x| x.wrapping_mul(12).wrapping_add(78)).map(|x| x.wrapping_mul(13).wrapping_add(78)).map(|x| x.wrapping_mul(14).wrapping_add(78)).map(|x| x.wrapping_mul(15).wrapping_add(78)).map(|x| x.wrapping_mul(16).wrapping_add(78)).map(|x| x.wrapping_mul(17).wrapping_add(78)).map(|x| x.wrapping_mul(18).wrapping_add(78)).map(|x| x.wrapping_mul(19).wrapping_add(78)).map(|x| x.wrapping_mul(20).wrapping_add(78)).map(|x| x.wrapping_mul(21).wrapping_add(78)).map(|x| x.wrapping_mul(22).wrapping_add(78)).map(|x| x.wrapping_mul(23).wrapping_add(78)).map(|x| x.wrapping_mul(24).wrapping_add(78)).map(|x| x.wrapping_mul(25).wrapping_add(78)).map(|x| x.wrapping_mul(26).wrapping_add(78)).map(|x| x.wrapping_mul(27).wrapping_add(78)).map(|x| x.wrapping_mul(28).wrapping_add(78)).map(|x| x.wrapping_mul(29).wrapping_add(78)).map(|x| x.wrapping_mul(30).wrapping_add(78)).map(|x| x.wrapping_mul(31).wrapping_add(78)).map(|x| x.wrapping_mul(32).wrapping_add(78)).map(|x| x.wrapping_mul(33).wrapping_add(78)).map(|x| x.wrapping_mul(34).wrapping_add(78)).map(|x| x.wrapping_mul(35).wrapping_add(78)).map(|x| x.wrapping_mul(36).wrapping_add(78)).map(|x| x.wrapping_mul(37).wrapping_add(78)).map(|x| x.wrapping_mul(38).wrapping_add(78)).map(|x| x.wrapping_mul(39).wrapping_add(78)).map(|x| x.wrapping_mul(40).wrapping_add(78)).map(|x| x.wrapping_mul(41).wrapping_add(78)).map(|x| x.wrapping_mul(42).wrapping_add(78)).fold(0, u64::wrapping_add) } +pub fn busy_79() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(79)).map(|x| x.wrapping_mul(4).wrapping_add(79)).map(|x| x.wrapping_mul(5).wrapping_add(79)).map(|x| x.wrapping_mul(6).wrapping_add(79)).map(|x| x.wrapping_mul(7).wrapping_add(79)).map(|x| x.wrapping_mul(8).wrapping_add(79)).map(|x| x.wrapping_mul(9).wrapping_add(79)).map(|x| x.wrapping_mul(10).wrapping_add(79)).map(|x| x.wrapping_mul(11).wrapping_add(79)).map(|x| x.wrapping_mul(12).wrapping_add(79)).map(|x| x.wrapping_mul(13).wrapping_add(79)).map(|x| x.wrapping_mul(14).wrapping_add(79)).map(|x| x.wrapping_mul(15).wrapping_add(79)).map(|x| x.wrapping_mul(16).wrapping_add(79)).map(|x| x.wrapping_mul(17).wrapping_add(79)).map(|x| x.wrapping_mul(18).wrapping_add(79)).map(|x| x.wrapping_mul(19).wrapping_add(79)).map(|x| x.wrapping_mul(20).wrapping_add(79)).map(|x| x.wrapping_mul(21).wrapping_add(79)).map(|x| x.wrapping_mul(22).wrapping_add(79)).map(|x| x.wrapping_mul(23).wrapping_add(79)).map(|x| x.wrapping_mul(24).wrapping_add(79)).map(|x| x.wrapping_mul(25).wrapping_add(79)).map(|x| x.wrapping_mul(26).wrapping_add(79)).map(|x| x.wrapping_mul(27).wrapping_add(79)).map(|x| x.wrapping_mul(28).wrapping_add(79)).map(|x| x.wrapping_mul(29).wrapping_add(79)).map(|x| x.wrapping_mul(30).wrapping_add(79)).map(|x| x.wrapping_mul(31).wrapping_add(79)).map(|x| x.wrapping_mul(32).wrapping_add(79)).map(|x| x.wrapping_mul(33).wrapping_add(79)).map(|x| x.wrapping_mul(34).wrapping_add(79)).map(|x| x.wrapping_mul(35).wrapping_add(79)).map(|x| x.wrapping_mul(36).wrapping_add(79)).map(|x| x.wrapping_mul(37).wrapping_add(79)).map(|x| x.wrapping_mul(38).wrapping_add(79)).map(|x| x.wrapping_mul(39).wrapping_add(79)).map(|x| x.wrapping_mul(40).wrapping_add(79)).map(|x| x.wrapping_mul(41).wrapping_add(79)).map(|x| x.wrapping_mul(42).wrapping_add(79)).fold(0, u64::wrapping_add) } diff --git a/tests/smoke/Cargo.toml b/tests/smoke/Cargo.toml new file mode 100644 index 0000000..277730a --- /dev/null +++ b/tests/smoke/Cargo.toml @@ -0,0 +1,3 @@ +[workspace] +members = ["slow", "app"] +resolver = "2" diff --git a/tests/smoke/app/Cargo.toml b/tests/smoke/app/Cargo.toml new file mode 100644 index 0000000..3543f98 --- /dev/null +++ b/tests/smoke/app/Cargo.toml @@ -0,0 +1,7 @@ +[package] +name = "app" +version = "0.1.0" +edition = "2021" + +[dependencies] +slow = { path = "../slow" } diff --git a/tests/smoke/app/src/main.rs b/tests/smoke/app/src/main.rs new file mode 100644 index 0000000..bf64cbd --- /dev/null +++ b/tests/smoke/app/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + println!("{}", slow::make().0); +} diff --git a/tests/smoke/gen.py b/tests/smoke/gen.py new file mode 100644 index 0000000..8889c0e --- /dev/null +++ b/tests/smoke/gen.py @@ -0,0 +1,8 @@ +# Writes slow/src/lib.rs: a tiny interface over bodies that are expensive to +# type-check (long iterator chains of closures), so the crate's metadata is +# ready long before its bodies are checked. +lines = ["pub struct Widget(pub u64);", "", "pub fn make() -> Widget { Widget(busy_0()) }", ""] +for i in range(80): + chain = "(0..10u64)" + "".join(f".map(|x| x.wrapping_mul({j + 3}).wrapping_add({i}))" for j in range(40)) + lines.append(f"pub fn busy_{i}() -> u64 {{ {chain}.fold(0, u64::wrapping_add) }}") +open("slow/src/lib.rs", "w").write("\n".join(lines) + "\n") diff --git a/tests/smoke/slow/Cargo.toml b/tests/smoke/slow/Cargo.toml new file mode 100644 index 0000000..a28a660 --- /dev/null +++ b/tests/smoke/slow/Cargo.toml @@ -0,0 +1,4 @@ +[package] +name = "slow" +version = "0.1.0" +edition = "2021" diff --git a/tests/smoke/slow/src/lib.rs b/tests/smoke/slow/src/lib.rs new file mode 100644 index 0000000..6e72deb --- /dev/null +++ b/tests/smoke/slow/src/lib.rs @@ -0,0 +1,84 @@ +pub struct Widget(pub u64); + +pub fn make() -> Widget { Widget(busy_0()) } + +pub fn busy_0() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(0)).map(|x| x.wrapping_mul(4).wrapping_add(0)).map(|x| x.wrapping_mul(5).wrapping_add(0)).map(|x| x.wrapping_mul(6).wrapping_add(0)).map(|x| x.wrapping_mul(7).wrapping_add(0)).map(|x| x.wrapping_mul(8).wrapping_add(0)).map(|x| x.wrapping_mul(9).wrapping_add(0)).map(|x| x.wrapping_mul(10).wrapping_add(0)).map(|x| x.wrapping_mul(11).wrapping_add(0)).map(|x| x.wrapping_mul(12).wrapping_add(0)).map(|x| x.wrapping_mul(13).wrapping_add(0)).map(|x| x.wrapping_mul(14).wrapping_add(0)).map(|x| x.wrapping_mul(15).wrapping_add(0)).map(|x| x.wrapping_mul(16).wrapping_add(0)).map(|x| x.wrapping_mul(17).wrapping_add(0)).map(|x| x.wrapping_mul(18).wrapping_add(0)).map(|x| x.wrapping_mul(19).wrapping_add(0)).map(|x| x.wrapping_mul(20).wrapping_add(0)).map(|x| x.wrapping_mul(21).wrapping_add(0)).map(|x| x.wrapping_mul(22).wrapping_add(0)).map(|x| x.wrapping_mul(23).wrapping_add(0)).map(|x| x.wrapping_mul(24).wrapping_add(0)).map(|x| x.wrapping_mul(25).wrapping_add(0)).map(|x| x.wrapping_mul(26).wrapping_add(0)).map(|x| x.wrapping_mul(27).wrapping_add(0)).map(|x| x.wrapping_mul(28).wrapping_add(0)).map(|x| x.wrapping_mul(29).wrapping_add(0)).map(|x| x.wrapping_mul(30).wrapping_add(0)).map(|x| x.wrapping_mul(31).wrapping_add(0)).map(|x| x.wrapping_mul(32).wrapping_add(0)).map(|x| x.wrapping_mul(33).wrapping_add(0)).map(|x| x.wrapping_mul(34).wrapping_add(0)).map(|x| x.wrapping_mul(35).wrapping_add(0)).map(|x| x.wrapping_mul(36).wrapping_add(0)).map(|x| x.wrapping_mul(37).wrapping_add(0)).map(|x| x.wrapping_mul(38).wrapping_add(0)).map(|x| x.wrapping_mul(39).wrapping_add(0)).map(|x| x.wrapping_mul(40).wrapping_add(0)).map(|x| x.wrapping_mul(41).wrapping_add(0)).map(|x| x.wrapping_mul(42).wrapping_add(0)).fold(0, u64::wrapping_add) } +pub fn busy_1() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(1)).map(|x| x.wrapping_mul(4).wrapping_add(1)).map(|x| x.wrapping_mul(5).wrapping_add(1)).map(|x| x.wrapping_mul(6).wrapping_add(1)).map(|x| x.wrapping_mul(7).wrapping_add(1)).map(|x| x.wrapping_mul(8).wrapping_add(1)).map(|x| x.wrapping_mul(9).wrapping_add(1)).map(|x| x.wrapping_mul(10).wrapping_add(1)).map(|x| x.wrapping_mul(11).wrapping_add(1)).map(|x| x.wrapping_mul(12).wrapping_add(1)).map(|x| x.wrapping_mul(13).wrapping_add(1)).map(|x| x.wrapping_mul(14).wrapping_add(1)).map(|x| x.wrapping_mul(15).wrapping_add(1)).map(|x| x.wrapping_mul(16).wrapping_add(1)).map(|x| x.wrapping_mul(17).wrapping_add(1)).map(|x| x.wrapping_mul(18).wrapping_add(1)).map(|x| x.wrapping_mul(19).wrapping_add(1)).map(|x| x.wrapping_mul(20).wrapping_add(1)).map(|x| x.wrapping_mul(21).wrapping_add(1)).map(|x| x.wrapping_mul(22).wrapping_add(1)).map(|x| x.wrapping_mul(23).wrapping_add(1)).map(|x| x.wrapping_mul(24).wrapping_add(1)).map(|x| x.wrapping_mul(25).wrapping_add(1)).map(|x| x.wrapping_mul(26).wrapping_add(1)).map(|x| x.wrapping_mul(27).wrapping_add(1)).map(|x| x.wrapping_mul(28).wrapping_add(1)).map(|x| x.wrapping_mul(29).wrapping_add(1)).map(|x| x.wrapping_mul(30).wrapping_add(1)).map(|x| x.wrapping_mul(31).wrapping_add(1)).map(|x| x.wrapping_mul(32).wrapping_add(1)).map(|x| x.wrapping_mul(33).wrapping_add(1)).map(|x| x.wrapping_mul(34).wrapping_add(1)).map(|x| x.wrapping_mul(35).wrapping_add(1)).map(|x| x.wrapping_mul(36).wrapping_add(1)).map(|x| x.wrapping_mul(37).wrapping_add(1)).map(|x| x.wrapping_mul(38).wrapping_add(1)).map(|x| x.wrapping_mul(39).wrapping_add(1)).map(|x| x.wrapping_mul(40).wrapping_add(1)).map(|x| x.wrapping_mul(41).wrapping_add(1)).map(|x| x.wrapping_mul(42).wrapping_add(1)).fold(0, u64::wrapping_add) } +pub fn busy_2() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(2)).map(|x| x.wrapping_mul(4).wrapping_add(2)).map(|x| x.wrapping_mul(5).wrapping_add(2)).map(|x| x.wrapping_mul(6).wrapping_add(2)).map(|x| x.wrapping_mul(7).wrapping_add(2)).map(|x| x.wrapping_mul(8).wrapping_add(2)).map(|x| x.wrapping_mul(9).wrapping_add(2)).map(|x| x.wrapping_mul(10).wrapping_add(2)).map(|x| x.wrapping_mul(11).wrapping_add(2)).map(|x| x.wrapping_mul(12).wrapping_add(2)).map(|x| x.wrapping_mul(13).wrapping_add(2)).map(|x| x.wrapping_mul(14).wrapping_add(2)).map(|x| x.wrapping_mul(15).wrapping_add(2)).map(|x| x.wrapping_mul(16).wrapping_add(2)).map(|x| x.wrapping_mul(17).wrapping_add(2)).map(|x| x.wrapping_mul(18).wrapping_add(2)).map(|x| x.wrapping_mul(19).wrapping_add(2)).map(|x| x.wrapping_mul(20).wrapping_add(2)).map(|x| x.wrapping_mul(21).wrapping_add(2)).map(|x| x.wrapping_mul(22).wrapping_add(2)).map(|x| x.wrapping_mul(23).wrapping_add(2)).map(|x| x.wrapping_mul(24).wrapping_add(2)).map(|x| x.wrapping_mul(25).wrapping_add(2)).map(|x| x.wrapping_mul(26).wrapping_add(2)).map(|x| x.wrapping_mul(27).wrapping_add(2)).map(|x| x.wrapping_mul(28).wrapping_add(2)).map(|x| x.wrapping_mul(29).wrapping_add(2)).map(|x| x.wrapping_mul(30).wrapping_add(2)).map(|x| x.wrapping_mul(31).wrapping_add(2)).map(|x| x.wrapping_mul(32).wrapping_add(2)).map(|x| x.wrapping_mul(33).wrapping_add(2)).map(|x| x.wrapping_mul(34).wrapping_add(2)).map(|x| x.wrapping_mul(35).wrapping_add(2)).map(|x| x.wrapping_mul(36).wrapping_add(2)).map(|x| x.wrapping_mul(37).wrapping_add(2)).map(|x| x.wrapping_mul(38).wrapping_add(2)).map(|x| x.wrapping_mul(39).wrapping_add(2)).map(|x| x.wrapping_mul(40).wrapping_add(2)).map(|x| x.wrapping_mul(41).wrapping_add(2)).map(|x| x.wrapping_mul(42).wrapping_add(2)).fold(0, u64::wrapping_add) } +pub fn busy_3() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(3)).map(|x| x.wrapping_mul(4).wrapping_add(3)).map(|x| x.wrapping_mul(5).wrapping_add(3)).map(|x| x.wrapping_mul(6).wrapping_add(3)).map(|x| x.wrapping_mul(7).wrapping_add(3)).map(|x| x.wrapping_mul(8).wrapping_add(3)).map(|x| x.wrapping_mul(9).wrapping_add(3)).map(|x| x.wrapping_mul(10).wrapping_add(3)).map(|x| x.wrapping_mul(11).wrapping_add(3)).map(|x| x.wrapping_mul(12).wrapping_add(3)).map(|x| x.wrapping_mul(13).wrapping_add(3)).map(|x| x.wrapping_mul(14).wrapping_add(3)).map(|x| x.wrapping_mul(15).wrapping_add(3)).map(|x| x.wrapping_mul(16).wrapping_add(3)).map(|x| x.wrapping_mul(17).wrapping_add(3)).map(|x| x.wrapping_mul(18).wrapping_add(3)).map(|x| x.wrapping_mul(19).wrapping_add(3)).map(|x| x.wrapping_mul(20).wrapping_add(3)).map(|x| x.wrapping_mul(21).wrapping_add(3)).map(|x| x.wrapping_mul(22).wrapping_add(3)).map(|x| x.wrapping_mul(23).wrapping_add(3)).map(|x| x.wrapping_mul(24).wrapping_add(3)).map(|x| x.wrapping_mul(25).wrapping_add(3)).map(|x| x.wrapping_mul(26).wrapping_add(3)).map(|x| x.wrapping_mul(27).wrapping_add(3)).map(|x| x.wrapping_mul(28).wrapping_add(3)).map(|x| x.wrapping_mul(29).wrapping_add(3)).map(|x| x.wrapping_mul(30).wrapping_add(3)).map(|x| x.wrapping_mul(31).wrapping_add(3)).map(|x| x.wrapping_mul(32).wrapping_add(3)).map(|x| x.wrapping_mul(33).wrapping_add(3)).map(|x| x.wrapping_mul(34).wrapping_add(3)).map(|x| x.wrapping_mul(35).wrapping_add(3)).map(|x| x.wrapping_mul(36).wrapping_add(3)).map(|x| x.wrapping_mul(37).wrapping_add(3)).map(|x| x.wrapping_mul(38).wrapping_add(3)).map(|x| x.wrapping_mul(39).wrapping_add(3)).map(|x| x.wrapping_mul(40).wrapping_add(3)).map(|x| x.wrapping_mul(41).wrapping_add(3)).map(|x| x.wrapping_mul(42).wrapping_add(3)).fold(0, u64::wrapping_add) } +pub fn busy_4() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(4)).map(|x| x.wrapping_mul(4).wrapping_add(4)).map(|x| x.wrapping_mul(5).wrapping_add(4)).map(|x| x.wrapping_mul(6).wrapping_add(4)).map(|x| x.wrapping_mul(7).wrapping_add(4)).map(|x| x.wrapping_mul(8).wrapping_add(4)).map(|x| x.wrapping_mul(9).wrapping_add(4)).map(|x| x.wrapping_mul(10).wrapping_add(4)).map(|x| x.wrapping_mul(11).wrapping_add(4)).map(|x| x.wrapping_mul(12).wrapping_add(4)).map(|x| x.wrapping_mul(13).wrapping_add(4)).map(|x| x.wrapping_mul(14).wrapping_add(4)).map(|x| x.wrapping_mul(15).wrapping_add(4)).map(|x| x.wrapping_mul(16).wrapping_add(4)).map(|x| x.wrapping_mul(17).wrapping_add(4)).map(|x| x.wrapping_mul(18).wrapping_add(4)).map(|x| x.wrapping_mul(19).wrapping_add(4)).map(|x| x.wrapping_mul(20).wrapping_add(4)).map(|x| x.wrapping_mul(21).wrapping_add(4)).map(|x| x.wrapping_mul(22).wrapping_add(4)).map(|x| x.wrapping_mul(23).wrapping_add(4)).map(|x| x.wrapping_mul(24).wrapping_add(4)).map(|x| x.wrapping_mul(25).wrapping_add(4)).map(|x| x.wrapping_mul(26).wrapping_add(4)).map(|x| x.wrapping_mul(27).wrapping_add(4)).map(|x| x.wrapping_mul(28).wrapping_add(4)).map(|x| x.wrapping_mul(29).wrapping_add(4)).map(|x| x.wrapping_mul(30).wrapping_add(4)).map(|x| x.wrapping_mul(31).wrapping_add(4)).map(|x| x.wrapping_mul(32).wrapping_add(4)).map(|x| x.wrapping_mul(33).wrapping_add(4)).map(|x| x.wrapping_mul(34).wrapping_add(4)).map(|x| x.wrapping_mul(35).wrapping_add(4)).map(|x| x.wrapping_mul(36).wrapping_add(4)).map(|x| x.wrapping_mul(37).wrapping_add(4)).map(|x| x.wrapping_mul(38).wrapping_add(4)).map(|x| x.wrapping_mul(39).wrapping_add(4)).map(|x| x.wrapping_mul(40).wrapping_add(4)).map(|x| x.wrapping_mul(41).wrapping_add(4)).map(|x| x.wrapping_mul(42).wrapping_add(4)).fold(0, u64::wrapping_add) } +pub fn busy_5() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(5)).map(|x| x.wrapping_mul(4).wrapping_add(5)).map(|x| x.wrapping_mul(5).wrapping_add(5)).map(|x| x.wrapping_mul(6).wrapping_add(5)).map(|x| x.wrapping_mul(7).wrapping_add(5)).map(|x| x.wrapping_mul(8).wrapping_add(5)).map(|x| x.wrapping_mul(9).wrapping_add(5)).map(|x| x.wrapping_mul(10).wrapping_add(5)).map(|x| x.wrapping_mul(11).wrapping_add(5)).map(|x| x.wrapping_mul(12).wrapping_add(5)).map(|x| x.wrapping_mul(13).wrapping_add(5)).map(|x| x.wrapping_mul(14).wrapping_add(5)).map(|x| x.wrapping_mul(15).wrapping_add(5)).map(|x| x.wrapping_mul(16).wrapping_add(5)).map(|x| x.wrapping_mul(17).wrapping_add(5)).map(|x| x.wrapping_mul(18).wrapping_add(5)).map(|x| x.wrapping_mul(19).wrapping_add(5)).map(|x| x.wrapping_mul(20).wrapping_add(5)).map(|x| x.wrapping_mul(21).wrapping_add(5)).map(|x| x.wrapping_mul(22).wrapping_add(5)).map(|x| x.wrapping_mul(23).wrapping_add(5)).map(|x| x.wrapping_mul(24).wrapping_add(5)).map(|x| x.wrapping_mul(25).wrapping_add(5)).map(|x| x.wrapping_mul(26).wrapping_add(5)).map(|x| x.wrapping_mul(27).wrapping_add(5)).map(|x| x.wrapping_mul(28).wrapping_add(5)).map(|x| x.wrapping_mul(29).wrapping_add(5)).map(|x| x.wrapping_mul(30).wrapping_add(5)).map(|x| x.wrapping_mul(31).wrapping_add(5)).map(|x| x.wrapping_mul(32).wrapping_add(5)).map(|x| x.wrapping_mul(33).wrapping_add(5)).map(|x| x.wrapping_mul(34).wrapping_add(5)).map(|x| x.wrapping_mul(35).wrapping_add(5)).map(|x| x.wrapping_mul(36).wrapping_add(5)).map(|x| x.wrapping_mul(37).wrapping_add(5)).map(|x| x.wrapping_mul(38).wrapping_add(5)).map(|x| x.wrapping_mul(39).wrapping_add(5)).map(|x| x.wrapping_mul(40).wrapping_add(5)).map(|x| x.wrapping_mul(41).wrapping_add(5)).map(|x| x.wrapping_mul(42).wrapping_add(5)).fold(0, u64::wrapping_add) } +pub fn busy_6() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(6)).map(|x| x.wrapping_mul(4).wrapping_add(6)).map(|x| x.wrapping_mul(5).wrapping_add(6)).map(|x| x.wrapping_mul(6).wrapping_add(6)).map(|x| x.wrapping_mul(7).wrapping_add(6)).map(|x| x.wrapping_mul(8).wrapping_add(6)).map(|x| x.wrapping_mul(9).wrapping_add(6)).map(|x| x.wrapping_mul(10).wrapping_add(6)).map(|x| x.wrapping_mul(11).wrapping_add(6)).map(|x| x.wrapping_mul(12).wrapping_add(6)).map(|x| x.wrapping_mul(13).wrapping_add(6)).map(|x| x.wrapping_mul(14).wrapping_add(6)).map(|x| x.wrapping_mul(15).wrapping_add(6)).map(|x| x.wrapping_mul(16).wrapping_add(6)).map(|x| x.wrapping_mul(17).wrapping_add(6)).map(|x| x.wrapping_mul(18).wrapping_add(6)).map(|x| x.wrapping_mul(19).wrapping_add(6)).map(|x| x.wrapping_mul(20).wrapping_add(6)).map(|x| x.wrapping_mul(21).wrapping_add(6)).map(|x| x.wrapping_mul(22).wrapping_add(6)).map(|x| x.wrapping_mul(23).wrapping_add(6)).map(|x| x.wrapping_mul(24).wrapping_add(6)).map(|x| x.wrapping_mul(25).wrapping_add(6)).map(|x| x.wrapping_mul(26).wrapping_add(6)).map(|x| x.wrapping_mul(27).wrapping_add(6)).map(|x| x.wrapping_mul(28).wrapping_add(6)).map(|x| x.wrapping_mul(29).wrapping_add(6)).map(|x| x.wrapping_mul(30).wrapping_add(6)).map(|x| x.wrapping_mul(31).wrapping_add(6)).map(|x| x.wrapping_mul(32).wrapping_add(6)).map(|x| x.wrapping_mul(33).wrapping_add(6)).map(|x| x.wrapping_mul(34).wrapping_add(6)).map(|x| x.wrapping_mul(35).wrapping_add(6)).map(|x| x.wrapping_mul(36).wrapping_add(6)).map(|x| x.wrapping_mul(37).wrapping_add(6)).map(|x| x.wrapping_mul(38).wrapping_add(6)).map(|x| x.wrapping_mul(39).wrapping_add(6)).map(|x| x.wrapping_mul(40).wrapping_add(6)).map(|x| x.wrapping_mul(41).wrapping_add(6)).map(|x| x.wrapping_mul(42).wrapping_add(6)).fold(0, u64::wrapping_add) } +pub fn busy_7() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(7)).map(|x| x.wrapping_mul(4).wrapping_add(7)).map(|x| x.wrapping_mul(5).wrapping_add(7)).map(|x| x.wrapping_mul(6).wrapping_add(7)).map(|x| x.wrapping_mul(7).wrapping_add(7)).map(|x| x.wrapping_mul(8).wrapping_add(7)).map(|x| x.wrapping_mul(9).wrapping_add(7)).map(|x| x.wrapping_mul(10).wrapping_add(7)).map(|x| x.wrapping_mul(11).wrapping_add(7)).map(|x| x.wrapping_mul(12).wrapping_add(7)).map(|x| x.wrapping_mul(13).wrapping_add(7)).map(|x| x.wrapping_mul(14).wrapping_add(7)).map(|x| x.wrapping_mul(15).wrapping_add(7)).map(|x| x.wrapping_mul(16).wrapping_add(7)).map(|x| x.wrapping_mul(17).wrapping_add(7)).map(|x| x.wrapping_mul(18).wrapping_add(7)).map(|x| x.wrapping_mul(19).wrapping_add(7)).map(|x| x.wrapping_mul(20).wrapping_add(7)).map(|x| x.wrapping_mul(21).wrapping_add(7)).map(|x| x.wrapping_mul(22).wrapping_add(7)).map(|x| x.wrapping_mul(23).wrapping_add(7)).map(|x| x.wrapping_mul(24).wrapping_add(7)).map(|x| x.wrapping_mul(25).wrapping_add(7)).map(|x| x.wrapping_mul(26).wrapping_add(7)).map(|x| x.wrapping_mul(27).wrapping_add(7)).map(|x| x.wrapping_mul(28).wrapping_add(7)).map(|x| x.wrapping_mul(29).wrapping_add(7)).map(|x| x.wrapping_mul(30).wrapping_add(7)).map(|x| x.wrapping_mul(31).wrapping_add(7)).map(|x| x.wrapping_mul(32).wrapping_add(7)).map(|x| x.wrapping_mul(33).wrapping_add(7)).map(|x| x.wrapping_mul(34).wrapping_add(7)).map(|x| x.wrapping_mul(35).wrapping_add(7)).map(|x| x.wrapping_mul(36).wrapping_add(7)).map(|x| x.wrapping_mul(37).wrapping_add(7)).map(|x| x.wrapping_mul(38).wrapping_add(7)).map(|x| x.wrapping_mul(39).wrapping_add(7)).map(|x| x.wrapping_mul(40).wrapping_add(7)).map(|x| x.wrapping_mul(41).wrapping_add(7)).map(|x| x.wrapping_mul(42).wrapping_add(7)).fold(0, u64::wrapping_add) } +pub fn busy_8() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(8)).map(|x| x.wrapping_mul(4).wrapping_add(8)).map(|x| x.wrapping_mul(5).wrapping_add(8)).map(|x| x.wrapping_mul(6).wrapping_add(8)).map(|x| x.wrapping_mul(7).wrapping_add(8)).map(|x| x.wrapping_mul(8).wrapping_add(8)).map(|x| x.wrapping_mul(9).wrapping_add(8)).map(|x| x.wrapping_mul(10).wrapping_add(8)).map(|x| x.wrapping_mul(11).wrapping_add(8)).map(|x| x.wrapping_mul(12).wrapping_add(8)).map(|x| x.wrapping_mul(13).wrapping_add(8)).map(|x| x.wrapping_mul(14).wrapping_add(8)).map(|x| x.wrapping_mul(15).wrapping_add(8)).map(|x| x.wrapping_mul(16).wrapping_add(8)).map(|x| x.wrapping_mul(17).wrapping_add(8)).map(|x| x.wrapping_mul(18).wrapping_add(8)).map(|x| x.wrapping_mul(19).wrapping_add(8)).map(|x| x.wrapping_mul(20).wrapping_add(8)).map(|x| x.wrapping_mul(21).wrapping_add(8)).map(|x| x.wrapping_mul(22).wrapping_add(8)).map(|x| x.wrapping_mul(23).wrapping_add(8)).map(|x| x.wrapping_mul(24).wrapping_add(8)).map(|x| x.wrapping_mul(25).wrapping_add(8)).map(|x| x.wrapping_mul(26).wrapping_add(8)).map(|x| x.wrapping_mul(27).wrapping_add(8)).map(|x| x.wrapping_mul(28).wrapping_add(8)).map(|x| x.wrapping_mul(29).wrapping_add(8)).map(|x| x.wrapping_mul(30).wrapping_add(8)).map(|x| x.wrapping_mul(31).wrapping_add(8)).map(|x| x.wrapping_mul(32).wrapping_add(8)).map(|x| x.wrapping_mul(33).wrapping_add(8)).map(|x| x.wrapping_mul(34).wrapping_add(8)).map(|x| x.wrapping_mul(35).wrapping_add(8)).map(|x| x.wrapping_mul(36).wrapping_add(8)).map(|x| x.wrapping_mul(37).wrapping_add(8)).map(|x| x.wrapping_mul(38).wrapping_add(8)).map(|x| x.wrapping_mul(39).wrapping_add(8)).map(|x| x.wrapping_mul(40).wrapping_add(8)).map(|x| x.wrapping_mul(41).wrapping_add(8)).map(|x| x.wrapping_mul(42).wrapping_add(8)).fold(0, u64::wrapping_add) } +pub fn busy_9() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(9)).map(|x| x.wrapping_mul(4).wrapping_add(9)).map(|x| x.wrapping_mul(5).wrapping_add(9)).map(|x| x.wrapping_mul(6).wrapping_add(9)).map(|x| x.wrapping_mul(7).wrapping_add(9)).map(|x| x.wrapping_mul(8).wrapping_add(9)).map(|x| x.wrapping_mul(9).wrapping_add(9)).map(|x| x.wrapping_mul(10).wrapping_add(9)).map(|x| x.wrapping_mul(11).wrapping_add(9)).map(|x| x.wrapping_mul(12).wrapping_add(9)).map(|x| x.wrapping_mul(13).wrapping_add(9)).map(|x| x.wrapping_mul(14).wrapping_add(9)).map(|x| x.wrapping_mul(15).wrapping_add(9)).map(|x| x.wrapping_mul(16).wrapping_add(9)).map(|x| x.wrapping_mul(17).wrapping_add(9)).map(|x| x.wrapping_mul(18).wrapping_add(9)).map(|x| x.wrapping_mul(19).wrapping_add(9)).map(|x| x.wrapping_mul(20).wrapping_add(9)).map(|x| x.wrapping_mul(21).wrapping_add(9)).map(|x| x.wrapping_mul(22).wrapping_add(9)).map(|x| x.wrapping_mul(23).wrapping_add(9)).map(|x| x.wrapping_mul(24).wrapping_add(9)).map(|x| x.wrapping_mul(25).wrapping_add(9)).map(|x| x.wrapping_mul(26).wrapping_add(9)).map(|x| x.wrapping_mul(27).wrapping_add(9)).map(|x| x.wrapping_mul(28).wrapping_add(9)).map(|x| x.wrapping_mul(29).wrapping_add(9)).map(|x| x.wrapping_mul(30).wrapping_add(9)).map(|x| x.wrapping_mul(31).wrapping_add(9)).map(|x| x.wrapping_mul(32).wrapping_add(9)).map(|x| x.wrapping_mul(33).wrapping_add(9)).map(|x| x.wrapping_mul(34).wrapping_add(9)).map(|x| x.wrapping_mul(35).wrapping_add(9)).map(|x| x.wrapping_mul(36).wrapping_add(9)).map(|x| x.wrapping_mul(37).wrapping_add(9)).map(|x| x.wrapping_mul(38).wrapping_add(9)).map(|x| x.wrapping_mul(39).wrapping_add(9)).map(|x| x.wrapping_mul(40).wrapping_add(9)).map(|x| x.wrapping_mul(41).wrapping_add(9)).map(|x| x.wrapping_mul(42).wrapping_add(9)).fold(0, u64::wrapping_add) } +pub fn busy_10() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(10)).map(|x| x.wrapping_mul(4).wrapping_add(10)).map(|x| x.wrapping_mul(5).wrapping_add(10)).map(|x| x.wrapping_mul(6).wrapping_add(10)).map(|x| x.wrapping_mul(7).wrapping_add(10)).map(|x| x.wrapping_mul(8).wrapping_add(10)).map(|x| x.wrapping_mul(9).wrapping_add(10)).map(|x| x.wrapping_mul(10).wrapping_add(10)).map(|x| x.wrapping_mul(11).wrapping_add(10)).map(|x| x.wrapping_mul(12).wrapping_add(10)).map(|x| x.wrapping_mul(13).wrapping_add(10)).map(|x| x.wrapping_mul(14).wrapping_add(10)).map(|x| x.wrapping_mul(15).wrapping_add(10)).map(|x| x.wrapping_mul(16).wrapping_add(10)).map(|x| x.wrapping_mul(17).wrapping_add(10)).map(|x| x.wrapping_mul(18).wrapping_add(10)).map(|x| x.wrapping_mul(19).wrapping_add(10)).map(|x| x.wrapping_mul(20).wrapping_add(10)).map(|x| x.wrapping_mul(21).wrapping_add(10)).map(|x| x.wrapping_mul(22).wrapping_add(10)).map(|x| x.wrapping_mul(23).wrapping_add(10)).map(|x| x.wrapping_mul(24).wrapping_add(10)).map(|x| x.wrapping_mul(25).wrapping_add(10)).map(|x| x.wrapping_mul(26).wrapping_add(10)).map(|x| x.wrapping_mul(27).wrapping_add(10)).map(|x| x.wrapping_mul(28).wrapping_add(10)).map(|x| x.wrapping_mul(29).wrapping_add(10)).map(|x| x.wrapping_mul(30).wrapping_add(10)).map(|x| x.wrapping_mul(31).wrapping_add(10)).map(|x| x.wrapping_mul(32).wrapping_add(10)).map(|x| x.wrapping_mul(33).wrapping_add(10)).map(|x| x.wrapping_mul(34).wrapping_add(10)).map(|x| x.wrapping_mul(35).wrapping_add(10)).map(|x| x.wrapping_mul(36).wrapping_add(10)).map(|x| x.wrapping_mul(37).wrapping_add(10)).map(|x| x.wrapping_mul(38).wrapping_add(10)).map(|x| x.wrapping_mul(39).wrapping_add(10)).map(|x| x.wrapping_mul(40).wrapping_add(10)).map(|x| x.wrapping_mul(41).wrapping_add(10)).map(|x| x.wrapping_mul(42).wrapping_add(10)).fold(0, u64::wrapping_add) } +pub fn busy_11() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(11)).map(|x| x.wrapping_mul(4).wrapping_add(11)).map(|x| x.wrapping_mul(5).wrapping_add(11)).map(|x| x.wrapping_mul(6).wrapping_add(11)).map(|x| x.wrapping_mul(7).wrapping_add(11)).map(|x| x.wrapping_mul(8).wrapping_add(11)).map(|x| x.wrapping_mul(9).wrapping_add(11)).map(|x| x.wrapping_mul(10).wrapping_add(11)).map(|x| x.wrapping_mul(11).wrapping_add(11)).map(|x| x.wrapping_mul(12).wrapping_add(11)).map(|x| x.wrapping_mul(13).wrapping_add(11)).map(|x| x.wrapping_mul(14).wrapping_add(11)).map(|x| x.wrapping_mul(15).wrapping_add(11)).map(|x| x.wrapping_mul(16).wrapping_add(11)).map(|x| x.wrapping_mul(17).wrapping_add(11)).map(|x| x.wrapping_mul(18).wrapping_add(11)).map(|x| x.wrapping_mul(19).wrapping_add(11)).map(|x| x.wrapping_mul(20).wrapping_add(11)).map(|x| x.wrapping_mul(21).wrapping_add(11)).map(|x| x.wrapping_mul(22).wrapping_add(11)).map(|x| x.wrapping_mul(23).wrapping_add(11)).map(|x| x.wrapping_mul(24).wrapping_add(11)).map(|x| x.wrapping_mul(25).wrapping_add(11)).map(|x| x.wrapping_mul(26).wrapping_add(11)).map(|x| x.wrapping_mul(27).wrapping_add(11)).map(|x| x.wrapping_mul(28).wrapping_add(11)).map(|x| x.wrapping_mul(29).wrapping_add(11)).map(|x| x.wrapping_mul(30).wrapping_add(11)).map(|x| x.wrapping_mul(31).wrapping_add(11)).map(|x| x.wrapping_mul(32).wrapping_add(11)).map(|x| x.wrapping_mul(33).wrapping_add(11)).map(|x| x.wrapping_mul(34).wrapping_add(11)).map(|x| x.wrapping_mul(35).wrapping_add(11)).map(|x| x.wrapping_mul(36).wrapping_add(11)).map(|x| x.wrapping_mul(37).wrapping_add(11)).map(|x| x.wrapping_mul(38).wrapping_add(11)).map(|x| x.wrapping_mul(39).wrapping_add(11)).map(|x| x.wrapping_mul(40).wrapping_add(11)).map(|x| x.wrapping_mul(41).wrapping_add(11)).map(|x| x.wrapping_mul(42).wrapping_add(11)).fold(0, u64::wrapping_add) } +pub fn busy_12() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(12)).map(|x| x.wrapping_mul(4).wrapping_add(12)).map(|x| x.wrapping_mul(5).wrapping_add(12)).map(|x| x.wrapping_mul(6).wrapping_add(12)).map(|x| x.wrapping_mul(7).wrapping_add(12)).map(|x| x.wrapping_mul(8).wrapping_add(12)).map(|x| x.wrapping_mul(9).wrapping_add(12)).map(|x| x.wrapping_mul(10).wrapping_add(12)).map(|x| x.wrapping_mul(11).wrapping_add(12)).map(|x| x.wrapping_mul(12).wrapping_add(12)).map(|x| x.wrapping_mul(13).wrapping_add(12)).map(|x| x.wrapping_mul(14).wrapping_add(12)).map(|x| x.wrapping_mul(15).wrapping_add(12)).map(|x| x.wrapping_mul(16).wrapping_add(12)).map(|x| x.wrapping_mul(17).wrapping_add(12)).map(|x| x.wrapping_mul(18).wrapping_add(12)).map(|x| x.wrapping_mul(19).wrapping_add(12)).map(|x| x.wrapping_mul(20).wrapping_add(12)).map(|x| x.wrapping_mul(21).wrapping_add(12)).map(|x| x.wrapping_mul(22).wrapping_add(12)).map(|x| x.wrapping_mul(23).wrapping_add(12)).map(|x| x.wrapping_mul(24).wrapping_add(12)).map(|x| x.wrapping_mul(25).wrapping_add(12)).map(|x| x.wrapping_mul(26).wrapping_add(12)).map(|x| x.wrapping_mul(27).wrapping_add(12)).map(|x| x.wrapping_mul(28).wrapping_add(12)).map(|x| x.wrapping_mul(29).wrapping_add(12)).map(|x| x.wrapping_mul(30).wrapping_add(12)).map(|x| x.wrapping_mul(31).wrapping_add(12)).map(|x| x.wrapping_mul(32).wrapping_add(12)).map(|x| x.wrapping_mul(33).wrapping_add(12)).map(|x| x.wrapping_mul(34).wrapping_add(12)).map(|x| x.wrapping_mul(35).wrapping_add(12)).map(|x| x.wrapping_mul(36).wrapping_add(12)).map(|x| x.wrapping_mul(37).wrapping_add(12)).map(|x| x.wrapping_mul(38).wrapping_add(12)).map(|x| x.wrapping_mul(39).wrapping_add(12)).map(|x| x.wrapping_mul(40).wrapping_add(12)).map(|x| x.wrapping_mul(41).wrapping_add(12)).map(|x| x.wrapping_mul(42).wrapping_add(12)).fold(0, u64::wrapping_add) } +pub fn busy_13() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(13)).map(|x| x.wrapping_mul(4).wrapping_add(13)).map(|x| x.wrapping_mul(5).wrapping_add(13)).map(|x| x.wrapping_mul(6).wrapping_add(13)).map(|x| x.wrapping_mul(7).wrapping_add(13)).map(|x| x.wrapping_mul(8).wrapping_add(13)).map(|x| x.wrapping_mul(9).wrapping_add(13)).map(|x| x.wrapping_mul(10).wrapping_add(13)).map(|x| x.wrapping_mul(11).wrapping_add(13)).map(|x| x.wrapping_mul(12).wrapping_add(13)).map(|x| x.wrapping_mul(13).wrapping_add(13)).map(|x| x.wrapping_mul(14).wrapping_add(13)).map(|x| x.wrapping_mul(15).wrapping_add(13)).map(|x| x.wrapping_mul(16).wrapping_add(13)).map(|x| x.wrapping_mul(17).wrapping_add(13)).map(|x| x.wrapping_mul(18).wrapping_add(13)).map(|x| x.wrapping_mul(19).wrapping_add(13)).map(|x| x.wrapping_mul(20).wrapping_add(13)).map(|x| x.wrapping_mul(21).wrapping_add(13)).map(|x| x.wrapping_mul(22).wrapping_add(13)).map(|x| x.wrapping_mul(23).wrapping_add(13)).map(|x| x.wrapping_mul(24).wrapping_add(13)).map(|x| x.wrapping_mul(25).wrapping_add(13)).map(|x| x.wrapping_mul(26).wrapping_add(13)).map(|x| x.wrapping_mul(27).wrapping_add(13)).map(|x| x.wrapping_mul(28).wrapping_add(13)).map(|x| x.wrapping_mul(29).wrapping_add(13)).map(|x| x.wrapping_mul(30).wrapping_add(13)).map(|x| x.wrapping_mul(31).wrapping_add(13)).map(|x| x.wrapping_mul(32).wrapping_add(13)).map(|x| x.wrapping_mul(33).wrapping_add(13)).map(|x| x.wrapping_mul(34).wrapping_add(13)).map(|x| x.wrapping_mul(35).wrapping_add(13)).map(|x| x.wrapping_mul(36).wrapping_add(13)).map(|x| x.wrapping_mul(37).wrapping_add(13)).map(|x| x.wrapping_mul(38).wrapping_add(13)).map(|x| x.wrapping_mul(39).wrapping_add(13)).map(|x| x.wrapping_mul(40).wrapping_add(13)).map(|x| x.wrapping_mul(41).wrapping_add(13)).map(|x| x.wrapping_mul(42).wrapping_add(13)).fold(0, u64::wrapping_add) } +pub fn busy_14() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(14)).map(|x| x.wrapping_mul(4).wrapping_add(14)).map(|x| x.wrapping_mul(5).wrapping_add(14)).map(|x| x.wrapping_mul(6).wrapping_add(14)).map(|x| x.wrapping_mul(7).wrapping_add(14)).map(|x| x.wrapping_mul(8).wrapping_add(14)).map(|x| x.wrapping_mul(9).wrapping_add(14)).map(|x| x.wrapping_mul(10).wrapping_add(14)).map(|x| x.wrapping_mul(11).wrapping_add(14)).map(|x| x.wrapping_mul(12).wrapping_add(14)).map(|x| x.wrapping_mul(13).wrapping_add(14)).map(|x| x.wrapping_mul(14).wrapping_add(14)).map(|x| x.wrapping_mul(15).wrapping_add(14)).map(|x| x.wrapping_mul(16).wrapping_add(14)).map(|x| x.wrapping_mul(17).wrapping_add(14)).map(|x| x.wrapping_mul(18).wrapping_add(14)).map(|x| x.wrapping_mul(19).wrapping_add(14)).map(|x| x.wrapping_mul(20).wrapping_add(14)).map(|x| x.wrapping_mul(21).wrapping_add(14)).map(|x| x.wrapping_mul(22).wrapping_add(14)).map(|x| x.wrapping_mul(23).wrapping_add(14)).map(|x| x.wrapping_mul(24).wrapping_add(14)).map(|x| x.wrapping_mul(25).wrapping_add(14)).map(|x| x.wrapping_mul(26).wrapping_add(14)).map(|x| x.wrapping_mul(27).wrapping_add(14)).map(|x| x.wrapping_mul(28).wrapping_add(14)).map(|x| x.wrapping_mul(29).wrapping_add(14)).map(|x| x.wrapping_mul(30).wrapping_add(14)).map(|x| x.wrapping_mul(31).wrapping_add(14)).map(|x| x.wrapping_mul(32).wrapping_add(14)).map(|x| x.wrapping_mul(33).wrapping_add(14)).map(|x| x.wrapping_mul(34).wrapping_add(14)).map(|x| x.wrapping_mul(35).wrapping_add(14)).map(|x| x.wrapping_mul(36).wrapping_add(14)).map(|x| x.wrapping_mul(37).wrapping_add(14)).map(|x| x.wrapping_mul(38).wrapping_add(14)).map(|x| x.wrapping_mul(39).wrapping_add(14)).map(|x| x.wrapping_mul(40).wrapping_add(14)).map(|x| x.wrapping_mul(41).wrapping_add(14)).map(|x| x.wrapping_mul(42).wrapping_add(14)).fold(0, u64::wrapping_add) } +pub fn busy_15() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(15)).map(|x| x.wrapping_mul(4).wrapping_add(15)).map(|x| x.wrapping_mul(5).wrapping_add(15)).map(|x| x.wrapping_mul(6).wrapping_add(15)).map(|x| x.wrapping_mul(7).wrapping_add(15)).map(|x| x.wrapping_mul(8).wrapping_add(15)).map(|x| x.wrapping_mul(9).wrapping_add(15)).map(|x| x.wrapping_mul(10).wrapping_add(15)).map(|x| x.wrapping_mul(11).wrapping_add(15)).map(|x| x.wrapping_mul(12).wrapping_add(15)).map(|x| x.wrapping_mul(13).wrapping_add(15)).map(|x| x.wrapping_mul(14).wrapping_add(15)).map(|x| x.wrapping_mul(15).wrapping_add(15)).map(|x| x.wrapping_mul(16).wrapping_add(15)).map(|x| x.wrapping_mul(17).wrapping_add(15)).map(|x| x.wrapping_mul(18).wrapping_add(15)).map(|x| x.wrapping_mul(19).wrapping_add(15)).map(|x| x.wrapping_mul(20).wrapping_add(15)).map(|x| x.wrapping_mul(21).wrapping_add(15)).map(|x| x.wrapping_mul(22).wrapping_add(15)).map(|x| x.wrapping_mul(23).wrapping_add(15)).map(|x| x.wrapping_mul(24).wrapping_add(15)).map(|x| x.wrapping_mul(25).wrapping_add(15)).map(|x| x.wrapping_mul(26).wrapping_add(15)).map(|x| x.wrapping_mul(27).wrapping_add(15)).map(|x| x.wrapping_mul(28).wrapping_add(15)).map(|x| x.wrapping_mul(29).wrapping_add(15)).map(|x| x.wrapping_mul(30).wrapping_add(15)).map(|x| x.wrapping_mul(31).wrapping_add(15)).map(|x| x.wrapping_mul(32).wrapping_add(15)).map(|x| x.wrapping_mul(33).wrapping_add(15)).map(|x| x.wrapping_mul(34).wrapping_add(15)).map(|x| x.wrapping_mul(35).wrapping_add(15)).map(|x| x.wrapping_mul(36).wrapping_add(15)).map(|x| x.wrapping_mul(37).wrapping_add(15)).map(|x| x.wrapping_mul(38).wrapping_add(15)).map(|x| x.wrapping_mul(39).wrapping_add(15)).map(|x| x.wrapping_mul(40).wrapping_add(15)).map(|x| x.wrapping_mul(41).wrapping_add(15)).map(|x| x.wrapping_mul(42).wrapping_add(15)).fold(0, u64::wrapping_add) } +pub fn busy_16() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(16)).map(|x| x.wrapping_mul(4).wrapping_add(16)).map(|x| x.wrapping_mul(5).wrapping_add(16)).map(|x| x.wrapping_mul(6).wrapping_add(16)).map(|x| x.wrapping_mul(7).wrapping_add(16)).map(|x| x.wrapping_mul(8).wrapping_add(16)).map(|x| x.wrapping_mul(9).wrapping_add(16)).map(|x| x.wrapping_mul(10).wrapping_add(16)).map(|x| x.wrapping_mul(11).wrapping_add(16)).map(|x| x.wrapping_mul(12).wrapping_add(16)).map(|x| x.wrapping_mul(13).wrapping_add(16)).map(|x| x.wrapping_mul(14).wrapping_add(16)).map(|x| x.wrapping_mul(15).wrapping_add(16)).map(|x| x.wrapping_mul(16).wrapping_add(16)).map(|x| x.wrapping_mul(17).wrapping_add(16)).map(|x| x.wrapping_mul(18).wrapping_add(16)).map(|x| x.wrapping_mul(19).wrapping_add(16)).map(|x| x.wrapping_mul(20).wrapping_add(16)).map(|x| x.wrapping_mul(21).wrapping_add(16)).map(|x| x.wrapping_mul(22).wrapping_add(16)).map(|x| x.wrapping_mul(23).wrapping_add(16)).map(|x| x.wrapping_mul(24).wrapping_add(16)).map(|x| x.wrapping_mul(25).wrapping_add(16)).map(|x| x.wrapping_mul(26).wrapping_add(16)).map(|x| x.wrapping_mul(27).wrapping_add(16)).map(|x| x.wrapping_mul(28).wrapping_add(16)).map(|x| x.wrapping_mul(29).wrapping_add(16)).map(|x| x.wrapping_mul(30).wrapping_add(16)).map(|x| x.wrapping_mul(31).wrapping_add(16)).map(|x| x.wrapping_mul(32).wrapping_add(16)).map(|x| x.wrapping_mul(33).wrapping_add(16)).map(|x| x.wrapping_mul(34).wrapping_add(16)).map(|x| x.wrapping_mul(35).wrapping_add(16)).map(|x| x.wrapping_mul(36).wrapping_add(16)).map(|x| x.wrapping_mul(37).wrapping_add(16)).map(|x| x.wrapping_mul(38).wrapping_add(16)).map(|x| x.wrapping_mul(39).wrapping_add(16)).map(|x| x.wrapping_mul(40).wrapping_add(16)).map(|x| x.wrapping_mul(41).wrapping_add(16)).map(|x| x.wrapping_mul(42).wrapping_add(16)).fold(0, u64::wrapping_add) } +pub fn busy_17() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(17)).map(|x| x.wrapping_mul(4).wrapping_add(17)).map(|x| x.wrapping_mul(5).wrapping_add(17)).map(|x| x.wrapping_mul(6).wrapping_add(17)).map(|x| x.wrapping_mul(7).wrapping_add(17)).map(|x| x.wrapping_mul(8).wrapping_add(17)).map(|x| x.wrapping_mul(9).wrapping_add(17)).map(|x| x.wrapping_mul(10).wrapping_add(17)).map(|x| x.wrapping_mul(11).wrapping_add(17)).map(|x| x.wrapping_mul(12).wrapping_add(17)).map(|x| x.wrapping_mul(13).wrapping_add(17)).map(|x| x.wrapping_mul(14).wrapping_add(17)).map(|x| x.wrapping_mul(15).wrapping_add(17)).map(|x| x.wrapping_mul(16).wrapping_add(17)).map(|x| x.wrapping_mul(17).wrapping_add(17)).map(|x| x.wrapping_mul(18).wrapping_add(17)).map(|x| x.wrapping_mul(19).wrapping_add(17)).map(|x| x.wrapping_mul(20).wrapping_add(17)).map(|x| x.wrapping_mul(21).wrapping_add(17)).map(|x| x.wrapping_mul(22).wrapping_add(17)).map(|x| x.wrapping_mul(23).wrapping_add(17)).map(|x| x.wrapping_mul(24).wrapping_add(17)).map(|x| x.wrapping_mul(25).wrapping_add(17)).map(|x| x.wrapping_mul(26).wrapping_add(17)).map(|x| x.wrapping_mul(27).wrapping_add(17)).map(|x| x.wrapping_mul(28).wrapping_add(17)).map(|x| x.wrapping_mul(29).wrapping_add(17)).map(|x| x.wrapping_mul(30).wrapping_add(17)).map(|x| x.wrapping_mul(31).wrapping_add(17)).map(|x| x.wrapping_mul(32).wrapping_add(17)).map(|x| x.wrapping_mul(33).wrapping_add(17)).map(|x| x.wrapping_mul(34).wrapping_add(17)).map(|x| x.wrapping_mul(35).wrapping_add(17)).map(|x| x.wrapping_mul(36).wrapping_add(17)).map(|x| x.wrapping_mul(37).wrapping_add(17)).map(|x| x.wrapping_mul(38).wrapping_add(17)).map(|x| x.wrapping_mul(39).wrapping_add(17)).map(|x| x.wrapping_mul(40).wrapping_add(17)).map(|x| x.wrapping_mul(41).wrapping_add(17)).map(|x| x.wrapping_mul(42).wrapping_add(17)).fold(0, u64::wrapping_add) } +pub fn busy_18() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(18)).map(|x| x.wrapping_mul(4).wrapping_add(18)).map(|x| x.wrapping_mul(5).wrapping_add(18)).map(|x| x.wrapping_mul(6).wrapping_add(18)).map(|x| x.wrapping_mul(7).wrapping_add(18)).map(|x| x.wrapping_mul(8).wrapping_add(18)).map(|x| x.wrapping_mul(9).wrapping_add(18)).map(|x| x.wrapping_mul(10).wrapping_add(18)).map(|x| x.wrapping_mul(11).wrapping_add(18)).map(|x| x.wrapping_mul(12).wrapping_add(18)).map(|x| x.wrapping_mul(13).wrapping_add(18)).map(|x| x.wrapping_mul(14).wrapping_add(18)).map(|x| x.wrapping_mul(15).wrapping_add(18)).map(|x| x.wrapping_mul(16).wrapping_add(18)).map(|x| x.wrapping_mul(17).wrapping_add(18)).map(|x| x.wrapping_mul(18).wrapping_add(18)).map(|x| x.wrapping_mul(19).wrapping_add(18)).map(|x| x.wrapping_mul(20).wrapping_add(18)).map(|x| x.wrapping_mul(21).wrapping_add(18)).map(|x| x.wrapping_mul(22).wrapping_add(18)).map(|x| x.wrapping_mul(23).wrapping_add(18)).map(|x| x.wrapping_mul(24).wrapping_add(18)).map(|x| x.wrapping_mul(25).wrapping_add(18)).map(|x| x.wrapping_mul(26).wrapping_add(18)).map(|x| x.wrapping_mul(27).wrapping_add(18)).map(|x| x.wrapping_mul(28).wrapping_add(18)).map(|x| x.wrapping_mul(29).wrapping_add(18)).map(|x| x.wrapping_mul(30).wrapping_add(18)).map(|x| x.wrapping_mul(31).wrapping_add(18)).map(|x| x.wrapping_mul(32).wrapping_add(18)).map(|x| x.wrapping_mul(33).wrapping_add(18)).map(|x| x.wrapping_mul(34).wrapping_add(18)).map(|x| x.wrapping_mul(35).wrapping_add(18)).map(|x| x.wrapping_mul(36).wrapping_add(18)).map(|x| x.wrapping_mul(37).wrapping_add(18)).map(|x| x.wrapping_mul(38).wrapping_add(18)).map(|x| x.wrapping_mul(39).wrapping_add(18)).map(|x| x.wrapping_mul(40).wrapping_add(18)).map(|x| x.wrapping_mul(41).wrapping_add(18)).map(|x| x.wrapping_mul(42).wrapping_add(18)).fold(0, u64::wrapping_add) } +pub fn busy_19() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(19)).map(|x| x.wrapping_mul(4).wrapping_add(19)).map(|x| x.wrapping_mul(5).wrapping_add(19)).map(|x| x.wrapping_mul(6).wrapping_add(19)).map(|x| x.wrapping_mul(7).wrapping_add(19)).map(|x| x.wrapping_mul(8).wrapping_add(19)).map(|x| x.wrapping_mul(9).wrapping_add(19)).map(|x| x.wrapping_mul(10).wrapping_add(19)).map(|x| x.wrapping_mul(11).wrapping_add(19)).map(|x| x.wrapping_mul(12).wrapping_add(19)).map(|x| x.wrapping_mul(13).wrapping_add(19)).map(|x| x.wrapping_mul(14).wrapping_add(19)).map(|x| x.wrapping_mul(15).wrapping_add(19)).map(|x| x.wrapping_mul(16).wrapping_add(19)).map(|x| x.wrapping_mul(17).wrapping_add(19)).map(|x| x.wrapping_mul(18).wrapping_add(19)).map(|x| x.wrapping_mul(19).wrapping_add(19)).map(|x| x.wrapping_mul(20).wrapping_add(19)).map(|x| x.wrapping_mul(21).wrapping_add(19)).map(|x| x.wrapping_mul(22).wrapping_add(19)).map(|x| x.wrapping_mul(23).wrapping_add(19)).map(|x| x.wrapping_mul(24).wrapping_add(19)).map(|x| x.wrapping_mul(25).wrapping_add(19)).map(|x| x.wrapping_mul(26).wrapping_add(19)).map(|x| x.wrapping_mul(27).wrapping_add(19)).map(|x| x.wrapping_mul(28).wrapping_add(19)).map(|x| x.wrapping_mul(29).wrapping_add(19)).map(|x| x.wrapping_mul(30).wrapping_add(19)).map(|x| x.wrapping_mul(31).wrapping_add(19)).map(|x| x.wrapping_mul(32).wrapping_add(19)).map(|x| x.wrapping_mul(33).wrapping_add(19)).map(|x| x.wrapping_mul(34).wrapping_add(19)).map(|x| x.wrapping_mul(35).wrapping_add(19)).map(|x| x.wrapping_mul(36).wrapping_add(19)).map(|x| x.wrapping_mul(37).wrapping_add(19)).map(|x| x.wrapping_mul(38).wrapping_add(19)).map(|x| x.wrapping_mul(39).wrapping_add(19)).map(|x| x.wrapping_mul(40).wrapping_add(19)).map(|x| x.wrapping_mul(41).wrapping_add(19)).map(|x| x.wrapping_mul(42).wrapping_add(19)).fold(0, u64::wrapping_add) } +pub fn busy_20() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(20)).map(|x| x.wrapping_mul(4).wrapping_add(20)).map(|x| x.wrapping_mul(5).wrapping_add(20)).map(|x| x.wrapping_mul(6).wrapping_add(20)).map(|x| x.wrapping_mul(7).wrapping_add(20)).map(|x| x.wrapping_mul(8).wrapping_add(20)).map(|x| x.wrapping_mul(9).wrapping_add(20)).map(|x| x.wrapping_mul(10).wrapping_add(20)).map(|x| x.wrapping_mul(11).wrapping_add(20)).map(|x| x.wrapping_mul(12).wrapping_add(20)).map(|x| x.wrapping_mul(13).wrapping_add(20)).map(|x| x.wrapping_mul(14).wrapping_add(20)).map(|x| x.wrapping_mul(15).wrapping_add(20)).map(|x| x.wrapping_mul(16).wrapping_add(20)).map(|x| x.wrapping_mul(17).wrapping_add(20)).map(|x| x.wrapping_mul(18).wrapping_add(20)).map(|x| x.wrapping_mul(19).wrapping_add(20)).map(|x| x.wrapping_mul(20).wrapping_add(20)).map(|x| x.wrapping_mul(21).wrapping_add(20)).map(|x| x.wrapping_mul(22).wrapping_add(20)).map(|x| x.wrapping_mul(23).wrapping_add(20)).map(|x| x.wrapping_mul(24).wrapping_add(20)).map(|x| x.wrapping_mul(25).wrapping_add(20)).map(|x| x.wrapping_mul(26).wrapping_add(20)).map(|x| x.wrapping_mul(27).wrapping_add(20)).map(|x| x.wrapping_mul(28).wrapping_add(20)).map(|x| x.wrapping_mul(29).wrapping_add(20)).map(|x| x.wrapping_mul(30).wrapping_add(20)).map(|x| x.wrapping_mul(31).wrapping_add(20)).map(|x| x.wrapping_mul(32).wrapping_add(20)).map(|x| x.wrapping_mul(33).wrapping_add(20)).map(|x| x.wrapping_mul(34).wrapping_add(20)).map(|x| x.wrapping_mul(35).wrapping_add(20)).map(|x| x.wrapping_mul(36).wrapping_add(20)).map(|x| x.wrapping_mul(37).wrapping_add(20)).map(|x| x.wrapping_mul(38).wrapping_add(20)).map(|x| x.wrapping_mul(39).wrapping_add(20)).map(|x| x.wrapping_mul(40).wrapping_add(20)).map(|x| x.wrapping_mul(41).wrapping_add(20)).map(|x| x.wrapping_mul(42).wrapping_add(20)).fold(0, u64::wrapping_add) } +pub fn busy_21() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(21)).map(|x| x.wrapping_mul(4).wrapping_add(21)).map(|x| x.wrapping_mul(5).wrapping_add(21)).map(|x| x.wrapping_mul(6).wrapping_add(21)).map(|x| x.wrapping_mul(7).wrapping_add(21)).map(|x| x.wrapping_mul(8).wrapping_add(21)).map(|x| x.wrapping_mul(9).wrapping_add(21)).map(|x| x.wrapping_mul(10).wrapping_add(21)).map(|x| x.wrapping_mul(11).wrapping_add(21)).map(|x| x.wrapping_mul(12).wrapping_add(21)).map(|x| x.wrapping_mul(13).wrapping_add(21)).map(|x| x.wrapping_mul(14).wrapping_add(21)).map(|x| x.wrapping_mul(15).wrapping_add(21)).map(|x| x.wrapping_mul(16).wrapping_add(21)).map(|x| x.wrapping_mul(17).wrapping_add(21)).map(|x| x.wrapping_mul(18).wrapping_add(21)).map(|x| x.wrapping_mul(19).wrapping_add(21)).map(|x| x.wrapping_mul(20).wrapping_add(21)).map(|x| x.wrapping_mul(21).wrapping_add(21)).map(|x| x.wrapping_mul(22).wrapping_add(21)).map(|x| x.wrapping_mul(23).wrapping_add(21)).map(|x| x.wrapping_mul(24).wrapping_add(21)).map(|x| x.wrapping_mul(25).wrapping_add(21)).map(|x| x.wrapping_mul(26).wrapping_add(21)).map(|x| x.wrapping_mul(27).wrapping_add(21)).map(|x| x.wrapping_mul(28).wrapping_add(21)).map(|x| x.wrapping_mul(29).wrapping_add(21)).map(|x| x.wrapping_mul(30).wrapping_add(21)).map(|x| x.wrapping_mul(31).wrapping_add(21)).map(|x| x.wrapping_mul(32).wrapping_add(21)).map(|x| x.wrapping_mul(33).wrapping_add(21)).map(|x| x.wrapping_mul(34).wrapping_add(21)).map(|x| x.wrapping_mul(35).wrapping_add(21)).map(|x| x.wrapping_mul(36).wrapping_add(21)).map(|x| x.wrapping_mul(37).wrapping_add(21)).map(|x| x.wrapping_mul(38).wrapping_add(21)).map(|x| x.wrapping_mul(39).wrapping_add(21)).map(|x| x.wrapping_mul(40).wrapping_add(21)).map(|x| x.wrapping_mul(41).wrapping_add(21)).map(|x| x.wrapping_mul(42).wrapping_add(21)).fold(0, u64::wrapping_add) } +pub fn busy_22() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(22)).map(|x| x.wrapping_mul(4).wrapping_add(22)).map(|x| x.wrapping_mul(5).wrapping_add(22)).map(|x| x.wrapping_mul(6).wrapping_add(22)).map(|x| x.wrapping_mul(7).wrapping_add(22)).map(|x| x.wrapping_mul(8).wrapping_add(22)).map(|x| x.wrapping_mul(9).wrapping_add(22)).map(|x| x.wrapping_mul(10).wrapping_add(22)).map(|x| x.wrapping_mul(11).wrapping_add(22)).map(|x| x.wrapping_mul(12).wrapping_add(22)).map(|x| x.wrapping_mul(13).wrapping_add(22)).map(|x| x.wrapping_mul(14).wrapping_add(22)).map(|x| x.wrapping_mul(15).wrapping_add(22)).map(|x| x.wrapping_mul(16).wrapping_add(22)).map(|x| x.wrapping_mul(17).wrapping_add(22)).map(|x| x.wrapping_mul(18).wrapping_add(22)).map(|x| x.wrapping_mul(19).wrapping_add(22)).map(|x| x.wrapping_mul(20).wrapping_add(22)).map(|x| x.wrapping_mul(21).wrapping_add(22)).map(|x| x.wrapping_mul(22).wrapping_add(22)).map(|x| x.wrapping_mul(23).wrapping_add(22)).map(|x| x.wrapping_mul(24).wrapping_add(22)).map(|x| x.wrapping_mul(25).wrapping_add(22)).map(|x| x.wrapping_mul(26).wrapping_add(22)).map(|x| x.wrapping_mul(27).wrapping_add(22)).map(|x| x.wrapping_mul(28).wrapping_add(22)).map(|x| x.wrapping_mul(29).wrapping_add(22)).map(|x| x.wrapping_mul(30).wrapping_add(22)).map(|x| x.wrapping_mul(31).wrapping_add(22)).map(|x| x.wrapping_mul(32).wrapping_add(22)).map(|x| x.wrapping_mul(33).wrapping_add(22)).map(|x| x.wrapping_mul(34).wrapping_add(22)).map(|x| x.wrapping_mul(35).wrapping_add(22)).map(|x| x.wrapping_mul(36).wrapping_add(22)).map(|x| x.wrapping_mul(37).wrapping_add(22)).map(|x| x.wrapping_mul(38).wrapping_add(22)).map(|x| x.wrapping_mul(39).wrapping_add(22)).map(|x| x.wrapping_mul(40).wrapping_add(22)).map(|x| x.wrapping_mul(41).wrapping_add(22)).map(|x| x.wrapping_mul(42).wrapping_add(22)).fold(0, u64::wrapping_add) } +pub fn busy_23() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(23)).map(|x| x.wrapping_mul(4).wrapping_add(23)).map(|x| x.wrapping_mul(5).wrapping_add(23)).map(|x| x.wrapping_mul(6).wrapping_add(23)).map(|x| x.wrapping_mul(7).wrapping_add(23)).map(|x| x.wrapping_mul(8).wrapping_add(23)).map(|x| x.wrapping_mul(9).wrapping_add(23)).map(|x| x.wrapping_mul(10).wrapping_add(23)).map(|x| x.wrapping_mul(11).wrapping_add(23)).map(|x| x.wrapping_mul(12).wrapping_add(23)).map(|x| x.wrapping_mul(13).wrapping_add(23)).map(|x| x.wrapping_mul(14).wrapping_add(23)).map(|x| x.wrapping_mul(15).wrapping_add(23)).map(|x| x.wrapping_mul(16).wrapping_add(23)).map(|x| x.wrapping_mul(17).wrapping_add(23)).map(|x| x.wrapping_mul(18).wrapping_add(23)).map(|x| x.wrapping_mul(19).wrapping_add(23)).map(|x| x.wrapping_mul(20).wrapping_add(23)).map(|x| x.wrapping_mul(21).wrapping_add(23)).map(|x| x.wrapping_mul(22).wrapping_add(23)).map(|x| x.wrapping_mul(23).wrapping_add(23)).map(|x| x.wrapping_mul(24).wrapping_add(23)).map(|x| x.wrapping_mul(25).wrapping_add(23)).map(|x| x.wrapping_mul(26).wrapping_add(23)).map(|x| x.wrapping_mul(27).wrapping_add(23)).map(|x| x.wrapping_mul(28).wrapping_add(23)).map(|x| x.wrapping_mul(29).wrapping_add(23)).map(|x| x.wrapping_mul(30).wrapping_add(23)).map(|x| x.wrapping_mul(31).wrapping_add(23)).map(|x| x.wrapping_mul(32).wrapping_add(23)).map(|x| x.wrapping_mul(33).wrapping_add(23)).map(|x| x.wrapping_mul(34).wrapping_add(23)).map(|x| x.wrapping_mul(35).wrapping_add(23)).map(|x| x.wrapping_mul(36).wrapping_add(23)).map(|x| x.wrapping_mul(37).wrapping_add(23)).map(|x| x.wrapping_mul(38).wrapping_add(23)).map(|x| x.wrapping_mul(39).wrapping_add(23)).map(|x| x.wrapping_mul(40).wrapping_add(23)).map(|x| x.wrapping_mul(41).wrapping_add(23)).map(|x| x.wrapping_mul(42).wrapping_add(23)).fold(0, u64::wrapping_add) } +pub fn busy_24() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(24)).map(|x| x.wrapping_mul(4).wrapping_add(24)).map(|x| x.wrapping_mul(5).wrapping_add(24)).map(|x| x.wrapping_mul(6).wrapping_add(24)).map(|x| x.wrapping_mul(7).wrapping_add(24)).map(|x| x.wrapping_mul(8).wrapping_add(24)).map(|x| x.wrapping_mul(9).wrapping_add(24)).map(|x| x.wrapping_mul(10).wrapping_add(24)).map(|x| x.wrapping_mul(11).wrapping_add(24)).map(|x| x.wrapping_mul(12).wrapping_add(24)).map(|x| x.wrapping_mul(13).wrapping_add(24)).map(|x| x.wrapping_mul(14).wrapping_add(24)).map(|x| x.wrapping_mul(15).wrapping_add(24)).map(|x| x.wrapping_mul(16).wrapping_add(24)).map(|x| x.wrapping_mul(17).wrapping_add(24)).map(|x| x.wrapping_mul(18).wrapping_add(24)).map(|x| x.wrapping_mul(19).wrapping_add(24)).map(|x| x.wrapping_mul(20).wrapping_add(24)).map(|x| x.wrapping_mul(21).wrapping_add(24)).map(|x| x.wrapping_mul(22).wrapping_add(24)).map(|x| x.wrapping_mul(23).wrapping_add(24)).map(|x| x.wrapping_mul(24).wrapping_add(24)).map(|x| x.wrapping_mul(25).wrapping_add(24)).map(|x| x.wrapping_mul(26).wrapping_add(24)).map(|x| x.wrapping_mul(27).wrapping_add(24)).map(|x| x.wrapping_mul(28).wrapping_add(24)).map(|x| x.wrapping_mul(29).wrapping_add(24)).map(|x| x.wrapping_mul(30).wrapping_add(24)).map(|x| x.wrapping_mul(31).wrapping_add(24)).map(|x| x.wrapping_mul(32).wrapping_add(24)).map(|x| x.wrapping_mul(33).wrapping_add(24)).map(|x| x.wrapping_mul(34).wrapping_add(24)).map(|x| x.wrapping_mul(35).wrapping_add(24)).map(|x| x.wrapping_mul(36).wrapping_add(24)).map(|x| x.wrapping_mul(37).wrapping_add(24)).map(|x| x.wrapping_mul(38).wrapping_add(24)).map(|x| x.wrapping_mul(39).wrapping_add(24)).map(|x| x.wrapping_mul(40).wrapping_add(24)).map(|x| x.wrapping_mul(41).wrapping_add(24)).map(|x| x.wrapping_mul(42).wrapping_add(24)).fold(0, u64::wrapping_add) } +pub fn busy_25() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(25)).map(|x| x.wrapping_mul(4).wrapping_add(25)).map(|x| x.wrapping_mul(5).wrapping_add(25)).map(|x| x.wrapping_mul(6).wrapping_add(25)).map(|x| x.wrapping_mul(7).wrapping_add(25)).map(|x| x.wrapping_mul(8).wrapping_add(25)).map(|x| x.wrapping_mul(9).wrapping_add(25)).map(|x| x.wrapping_mul(10).wrapping_add(25)).map(|x| x.wrapping_mul(11).wrapping_add(25)).map(|x| x.wrapping_mul(12).wrapping_add(25)).map(|x| x.wrapping_mul(13).wrapping_add(25)).map(|x| x.wrapping_mul(14).wrapping_add(25)).map(|x| x.wrapping_mul(15).wrapping_add(25)).map(|x| x.wrapping_mul(16).wrapping_add(25)).map(|x| x.wrapping_mul(17).wrapping_add(25)).map(|x| x.wrapping_mul(18).wrapping_add(25)).map(|x| x.wrapping_mul(19).wrapping_add(25)).map(|x| x.wrapping_mul(20).wrapping_add(25)).map(|x| x.wrapping_mul(21).wrapping_add(25)).map(|x| x.wrapping_mul(22).wrapping_add(25)).map(|x| x.wrapping_mul(23).wrapping_add(25)).map(|x| x.wrapping_mul(24).wrapping_add(25)).map(|x| x.wrapping_mul(25).wrapping_add(25)).map(|x| x.wrapping_mul(26).wrapping_add(25)).map(|x| x.wrapping_mul(27).wrapping_add(25)).map(|x| x.wrapping_mul(28).wrapping_add(25)).map(|x| x.wrapping_mul(29).wrapping_add(25)).map(|x| x.wrapping_mul(30).wrapping_add(25)).map(|x| x.wrapping_mul(31).wrapping_add(25)).map(|x| x.wrapping_mul(32).wrapping_add(25)).map(|x| x.wrapping_mul(33).wrapping_add(25)).map(|x| x.wrapping_mul(34).wrapping_add(25)).map(|x| x.wrapping_mul(35).wrapping_add(25)).map(|x| x.wrapping_mul(36).wrapping_add(25)).map(|x| x.wrapping_mul(37).wrapping_add(25)).map(|x| x.wrapping_mul(38).wrapping_add(25)).map(|x| x.wrapping_mul(39).wrapping_add(25)).map(|x| x.wrapping_mul(40).wrapping_add(25)).map(|x| x.wrapping_mul(41).wrapping_add(25)).map(|x| x.wrapping_mul(42).wrapping_add(25)).fold(0, u64::wrapping_add) } +pub fn busy_26() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(26)).map(|x| x.wrapping_mul(4).wrapping_add(26)).map(|x| x.wrapping_mul(5).wrapping_add(26)).map(|x| x.wrapping_mul(6).wrapping_add(26)).map(|x| x.wrapping_mul(7).wrapping_add(26)).map(|x| x.wrapping_mul(8).wrapping_add(26)).map(|x| x.wrapping_mul(9).wrapping_add(26)).map(|x| x.wrapping_mul(10).wrapping_add(26)).map(|x| x.wrapping_mul(11).wrapping_add(26)).map(|x| x.wrapping_mul(12).wrapping_add(26)).map(|x| x.wrapping_mul(13).wrapping_add(26)).map(|x| x.wrapping_mul(14).wrapping_add(26)).map(|x| x.wrapping_mul(15).wrapping_add(26)).map(|x| x.wrapping_mul(16).wrapping_add(26)).map(|x| x.wrapping_mul(17).wrapping_add(26)).map(|x| x.wrapping_mul(18).wrapping_add(26)).map(|x| x.wrapping_mul(19).wrapping_add(26)).map(|x| x.wrapping_mul(20).wrapping_add(26)).map(|x| x.wrapping_mul(21).wrapping_add(26)).map(|x| x.wrapping_mul(22).wrapping_add(26)).map(|x| x.wrapping_mul(23).wrapping_add(26)).map(|x| x.wrapping_mul(24).wrapping_add(26)).map(|x| x.wrapping_mul(25).wrapping_add(26)).map(|x| x.wrapping_mul(26).wrapping_add(26)).map(|x| x.wrapping_mul(27).wrapping_add(26)).map(|x| x.wrapping_mul(28).wrapping_add(26)).map(|x| x.wrapping_mul(29).wrapping_add(26)).map(|x| x.wrapping_mul(30).wrapping_add(26)).map(|x| x.wrapping_mul(31).wrapping_add(26)).map(|x| x.wrapping_mul(32).wrapping_add(26)).map(|x| x.wrapping_mul(33).wrapping_add(26)).map(|x| x.wrapping_mul(34).wrapping_add(26)).map(|x| x.wrapping_mul(35).wrapping_add(26)).map(|x| x.wrapping_mul(36).wrapping_add(26)).map(|x| x.wrapping_mul(37).wrapping_add(26)).map(|x| x.wrapping_mul(38).wrapping_add(26)).map(|x| x.wrapping_mul(39).wrapping_add(26)).map(|x| x.wrapping_mul(40).wrapping_add(26)).map(|x| x.wrapping_mul(41).wrapping_add(26)).map(|x| x.wrapping_mul(42).wrapping_add(26)).fold(0, u64::wrapping_add) } +pub fn busy_27() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(27)).map(|x| x.wrapping_mul(4).wrapping_add(27)).map(|x| x.wrapping_mul(5).wrapping_add(27)).map(|x| x.wrapping_mul(6).wrapping_add(27)).map(|x| x.wrapping_mul(7).wrapping_add(27)).map(|x| x.wrapping_mul(8).wrapping_add(27)).map(|x| x.wrapping_mul(9).wrapping_add(27)).map(|x| x.wrapping_mul(10).wrapping_add(27)).map(|x| x.wrapping_mul(11).wrapping_add(27)).map(|x| x.wrapping_mul(12).wrapping_add(27)).map(|x| x.wrapping_mul(13).wrapping_add(27)).map(|x| x.wrapping_mul(14).wrapping_add(27)).map(|x| x.wrapping_mul(15).wrapping_add(27)).map(|x| x.wrapping_mul(16).wrapping_add(27)).map(|x| x.wrapping_mul(17).wrapping_add(27)).map(|x| x.wrapping_mul(18).wrapping_add(27)).map(|x| x.wrapping_mul(19).wrapping_add(27)).map(|x| x.wrapping_mul(20).wrapping_add(27)).map(|x| x.wrapping_mul(21).wrapping_add(27)).map(|x| x.wrapping_mul(22).wrapping_add(27)).map(|x| x.wrapping_mul(23).wrapping_add(27)).map(|x| x.wrapping_mul(24).wrapping_add(27)).map(|x| x.wrapping_mul(25).wrapping_add(27)).map(|x| x.wrapping_mul(26).wrapping_add(27)).map(|x| x.wrapping_mul(27).wrapping_add(27)).map(|x| x.wrapping_mul(28).wrapping_add(27)).map(|x| x.wrapping_mul(29).wrapping_add(27)).map(|x| x.wrapping_mul(30).wrapping_add(27)).map(|x| x.wrapping_mul(31).wrapping_add(27)).map(|x| x.wrapping_mul(32).wrapping_add(27)).map(|x| x.wrapping_mul(33).wrapping_add(27)).map(|x| x.wrapping_mul(34).wrapping_add(27)).map(|x| x.wrapping_mul(35).wrapping_add(27)).map(|x| x.wrapping_mul(36).wrapping_add(27)).map(|x| x.wrapping_mul(37).wrapping_add(27)).map(|x| x.wrapping_mul(38).wrapping_add(27)).map(|x| x.wrapping_mul(39).wrapping_add(27)).map(|x| x.wrapping_mul(40).wrapping_add(27)).map(|x| x.wrapping_mul(41).wrapping_add(27)).map(|x| x.wrapping_mul(42).wrapping_add(27)).fold(0, u64::wrapping_add) } +pub fn busy_28() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(28)).map(|x| x.wrapping_mul(4).wrapping_add(28)).map(|x| x.wrapping_mul(5).wrapping_add(28)).map(|x| x.wrapping_mul(6).wrapping_add(28)).map(|x| x.wrapping_mul(7).wrapping_add(28)).map(|x| x.wrapping_mul(8).wrapping_add(28)).map(|x| x.wrapping_mul(9).wrapping_add(28)).map(|x| x.wrapping_mul(10).wrapping_add(28)).map(|x| x.wrapping_mul(11).wrapping_add(28)).map(|x| x.wrapping_mul(12).wrapping_add(28)).map(|x| x.wrapping_mul(13).wrapping_add(28)).map(|x| x.wrapping_mul(14).wrapping_add(28)).map(|x| x.wrapping_mul(15).wrapping_add(28)).map(|x| x.wrapping_mul(16).wrapping_add(28)).map(|x| x.wrapping_mul(17).wrapping_add(28)).map(|x| x.wrapping_mul(18).wrapping_add(28)).map(|x| x.wrapping_mul(19).wrapping_add(28)).map(|x| x.wrapping_mul(20).wrapping_add(28)).map(|x| x.wrapping_mul(21).wrapping_add(28)).map(|x| x.wrapping_mul(22).wrapping_add(28)).map(|x| x.wrapping_mul(23).wrapping_add(28)).map(|x| x.wrapping_mul(24).wrapping_add(28)).map(|x| x.wrapping_mul(25).wrapping_add(28)).map(|x| x.wrapping_mul(26).wrapping_add(28)).map(|x| x.wrapping_mul(27).wrapping_add(28)).map(|x| x.wrapping_mul(28).wrapping_add(28)).map(|x| x.wrapping_mul(29).wrapping_add(28)).map(|x| x.wrapping_mul(30).wrapping_add(28)).map(|x| x.wrapping_mul(31).wrapping_add(28)).map(|x| x.wrapping_mul(32).wrapping_add(28)).map(|x| x.wrapping_mul(33).wrapping_add(28)).map(|x| x.wrapping_mul(34).wrapping_add(28)).map(|x| x.wrapping_mul(35).wrapping_add(28)).map(|x| x.wrapping_mul(36).wrapping_add(28)).map(|x| x.wrapping_mul(37).wrapping_add(28)).map(|x| x.wrapping_mul(38).wrapping_add(28)).map(|x| x.wrapping_mul(39).wrapping_add(28)).map(|x| x.wrapping_mul(40).wrapping_add(28)).map(|x| x.wrapping_mul(41).wrapping_add(28)).map(|x| x.wrapping_mul(42).wrapping_add(28)).fold(0, u64::wrapping_add) } +pub fn busy_29() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(29)).map(|x| x.wrapping_mul(4).wrapping_add(29)).map(|x| x.wrapping_mul(5).wrapping_add(29)).map(|x| x.wrapping_mul(6).wrapping_add(29)).map(|x| x.wrapping_mul(7).wrapping_add(29)).map(|x| x.wrapping_mul(8).wrapping_add(29)).map(|x| x.wrapping_mul(9).wrapping_add(29)).map(|x| x.wrapping_mul(10).wrapping_add(29)).map(|x| x.wrapping_mul(11).wrapping_add(29)).map(|x| x.wrapping_mul(12).wrapping_add(29)).map(|x| x.wrapping_mul(13).wrapping_add(29)).map(|x| x.wrapping_mul(14).wrapping_add(29)).map(|x| x.wrapping_mul(15).wrapping_add(29)).map(|x| x.wrapping_mul(16).wrapping_add(29)).map(|x| x.wrapping_mul(17).wrapping_add(29)).map(|x| x.wrapping_mul(18).wrapping_add(29)).map(|x| x.wrapping_mul(19).wrapping_add(29)).map(|x| x.wrapping_mul(20).wrapping_add(29)).map(|x| x.wrapping_mul(21).wrapping_add(29)).map(|x| x.wrapping_mul(22).wrapping_add(29)).map(|x| x.wrapping_mul(23).wrapping_add(29)).map(|x| x.wrapping_mul(24).wrapping_add(29)).map(|x| x.wrapping_mul(25).wrapping_add(29)).map(|x| x.wrapping_mul(26).wrapping_add(29)).map(|x| x.wrapping_mul(27).wrapping_add(29)).map(|x| x.wrapping_mul(28).wrapping_add(29)).map(|x| x.wrapping_mul(29).wrapping_add(29)).map(|x| x.wrapping_mul(30).wrapping_add(29)).map(|x| x.wrapping_mul(31).wrapping_add(29)).map(|x| x.wrapping_mul(32).wrapping_add(29)).map(|x| x.wrapping_mul(33).wrapping_add(29)).map(|x| x.wrapping_mul(34).wrapping_add(29)).map(|x| x.wrapping_mul(35).wrapping_add(29)).map(|x| x.wrapping_mul(36).wrapping_add(29)).map(|x| x.wrapping_mul(37).wrapping_add(29)).map(|x| x.wrapping_mul(38).wrapping_add(29)).map(|x| x.wrapping_mul(39).wrapping_add(29)).map(|x| x.wrapping_mul(40).wrapping_add(29)).map(|x| x.wrapping_mul(41).wrapping_add(29)).map(|x| x.wrapping_mul(42).wrapping_add(29)).fold(0, u64::wrapping_add) } +pub fn busy_30() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(30)).map(|x| x.wrapping_mul(4).wrapping_add(30)).map(|x| x.wrapping_mul(5).wrapping_add(30)).map(|x| x.wrapping_mul(6).wrapping_add(30)).map(|x| x.wrapping_mul(7).wrapping_add(30)).map(|x| x.wrapping_mul(8).wrapping_add(30)).map(|x| x.wrapping_mul(9).wrapping_add(30)).map(|x| x.wrapping_mul(10).wrapping_add(30)).map(|x| x.wrapping_mul(11).wrapping_add(30)).map(|x| x.wrapping_mul(12).wrapping_add(30)).map(|x| x.wrapping_mul(13).wrapping_add(30)).map(|x| x.wrapping_mul(14).wrapping_add(30)).map(|x| x.wrapping_mul(15).wrapping_add(30)).map(|x| x.wrapping_mul(16).wrapping_add(30)).map(|x| x.wrapping_mul(17).wrapping_add(30)).map(|x| x.wrapping_mul(18).wrapping_add(30)).map(|x| x.wrapping_mul(19).wrapping_add(30)).map(|x| x.wrapping_mul(20).wrapping_add(30)).map(|x| x.wrapping_mul(21).wrapping_add(30)).map(|x| x.wrapping_mul(22).wrapping_add(30)).map(|x| x.wrapping_mul(23).wrapping_add(30)).map(|x| x.wrapping_mul(24).wrapping_add(30)).map(|x| x.wrapping_mul(25).wrapping_add(30)).map(|x| x.wrapping_mul(26).wrapping_add(30)).map(|x| x.wrapping_mul(27).wrapping_add(30)).map(|x| x.wrapping_mul(28).wrapping_add(30)).map(|x| x.wrapping_mul(29).wrapping_add(30)).map(|x| x.wrapping_mul(30).wrapping_add(30)).map(|x| x.wrapping_mul(31).wrapping_add(30)).map(|x| x.wrapping_mul(32).wrapping_add(30)).map(|x| x.wrapping_mul(33).wrapping_add(30)).map(|x| x.wrapping_mul(34).wrapping_add(30)).map(|x| x.wrapping_mul(35).wrapping_add(30)).map(|x| x.wrapping_mul(36).wrapping_add(30)).map(|x| x.wrapping_mul(37).wrapping_add(30)).map(|x| x.wrapping_mul(38).wrapping_add(30)).map(|x| x.wrapping_mul(39).wrapping_add(30)).map(|x| x.wrapping_mul(40).wrapping_add(30)).map(|x| x.wrapping_mul(41).wrapping_add(30)).map(|x| x.wrapping_mul(42).wrapping_add(30)).fold(0, u64::wrapping_add) } +pub fn busy_31() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(31)).map(|x| x.wrapping_mul(4).wrapping_add(31)).map(|x| x.wrapping_mul(5).wrapping_add(31)).map(|x| x.wrapping_mul(6).wrapping_add(31)).map(|x| x.wrapping_mul(7).wrapping_add(31)).map(|x| x.wrapping_mul(8).wrapping_add(31)).map(|x| x.wrapping_mul(9).wrapping_add(31)).map(|x| x.wrapping_mul(10).wrapping_add(31)).map(|x| x.wrapping_mul(11).wrapping_add(31)).map(|x| x.wrapping_mul(12).wrapping_add(31)).map(|x| x.wrapping_mul(13).wrapping_add(31)).map(|x| x.wrapping_mul(14).wrapping_add(31)).map(|x| x.wrapping_mul(15).wrapping_add(31)).map(|x| x.wrapping_mul(16).wrapping_add(31)).map(|x| x.wrapping_mul(17).wrapping_add(31)).map(|x| x.wrapping_mul(18).wrapping_add(31)).map(|x| x.wrapping_mul(19).wrapping_add(31)).map(|x| x.wrapping_mul(20).wrapping_add(31)).map(|x| x.wrapping_mul(21).wrapping_add(31)).map(|x| x.wrapping_mul(22).wrapping_add(31)).map(|x| x.wrapping_mul(23).wrapping_add(31)).map(|x| x.wrapping_mul(24).wrapping_add(31)).map(|x| x.wrapping_mul(25).wrapping_add(31)).map(|x| x.wrapping_mul(26).wrapping_add(31)).map(|x| x.wrapping_mul(27).wrapping_add(31)).map(|x| x.wrapping_mul(28).wrapping_add(31)).map(|x| x.wrapping_mul(29).wrapping_add(31)).map(|x| x.wrapping_mul(30).wrapping_add(31)).map(|x| x.wrapping_mul(31).wrapping_add(31)).map(|x| x.wrapping_mul(32).wrapping_add(31)).map(|x| x.wrapping_mul(33).wrapping_add(31)).map(|x| x.wrapping_mul(34).wrapping_add(31)).map(|x| x.wrapping_mul(35).wrapping_add(31)).map(|x| x.wrapping_mul(36).wrapping_add(31)).map(|x| x.wrapping_mul(37).wrapping_add(31)).map(|x| x.wrapping_mul(38).wrapping_add(31)).map(|x| x.wrapping_mul(39).wrapping_add(31)).map(|x| x.wrapping_mul(40).wrapping_add(31)).map(|x| x.wrapping_mul(41).wrapping_add(31)).map(|x| x.wrapping_mul(42).wrapping_add(31)).fold(0, u64::wrapping_add) } +pub fn busy_32() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(32)).map(|x| x.wrapping_mul(4).wrapping_add(32)).map(|x| x.wrapping_mul(5).wrapping_add(32)).map(|x| x.wrapping_mul(6).wrapping_add(32)).map(|x| x.wrapping_mul(7).wrapping_add(32)).map(|x| x.wrapping_mul(8).wrapping_add(32)).map(|x| x.wrapping_mul(9).wrapping_add(32)).map(|x| x.wrapping_mul(10).wrapping_add(32)).map(|x| x.wrapping_mul(11).wrapping_add(32)).map(|x| x.wrapping_mul(12).wrapping_add(32)).map(|x| x.wrapping_mul(13).wrapping_add(32)).map(|x| x.wrapping_mul(14).wrapping_add(32)).map(|x| x.wrapping_mul(15).wrapping_add(32)).map(|x| x.wrapping_mul(16).wrapping_add(32)).map(|x| x.wrapping_mul(17).wrapping_add(32)).map(|x| x.wrapping_mul(18).wrapping_add(32)).map(|x| x.wrapping_mul(19).wrapping_add(32)).map(|x| x.wrapping_mul(20).wrapping_add(32)).map(|x| x.wrapping_mul(21).wrapping_add(32)).map(|x| x.wrapping_mul(22).wrapping_add(32)).map(|x| x.wrapping_mul(23).wrapping_add(32)).map(|x| x.wrapping_mul(24).wrapping_add(32)).map(|x| x.wrapping_mul(25).wrapping_add(32)).map(|x| x.wrapping_mul(26).wrapping_add(32)).map(|x| x.wrapping_mul(27).wrapping_add(32)).map(|x| x.wrapping_mul(28).wrapping_add(32)).map(|x| x.wrapping_mul(29).wrapping_add(32)).map(|x| x.wrapping_mul(30).wrapping_add(32)).map(|x| x.wrapping_mul(31).wrapping_add(32)).map(|x| x.wrapping_mul(32).wrapping_add(32)).map(|x| x.wrapping_mul(33).wrapping_add(32)).map(|x| x.wrapping_mul(34).wrapping_add(32)).map(|x| x.wrapping_mul(35).wrapping_add(32)).map(|x| x.wrapping_mul(36).wrapping_add(32)).map(|x| x.wrapping_mul(37).wrapping_add(32)).map(|x| x.wrapping_mul(38).wrapping_add(32)).map(|x| x.wrapping_mul(39).wrapping_add(32)).map(|x| x.wrapping_mul(40).wrapping_add(32)).map(|x| x.wrapping_mul(41).wrapping_add(32)).map(|x| x.wrapping_mul(42).wrapping_add(32)).fold(0, u64::wrapping_add) } +pub fn busy_33() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(33)).map(|x| x.wrapping_mul(4).wrapping_add(33)).map(|x| x.wrapping_mul(5).wrapping_add(33)).map(|x| x.wrapping_mul(6).wrapping_add(33)).map(|x| x.wrapping_mul(7).wrapping_add(33)).map(|x| x.wrapping_mul(8).wrapping_add(33)).map(|x| x.wrapping_mul(9).wrapping_add(33)).map(|x| x.wrapping_mul(10).wrapping_add(33)).map(|x| x.wrapping_mul(11).wrapping_add(33)).map(|x| x.wrapping_mul(12).wrapping_add(33)).map(|x| x.wrapping_mul(13).wrapping_add(33)).map(|x| x.wrapping_mul(14).wrapping_add(33)).map(|x| x.wrapping_mul(15).wrapping_add(33)).map(|x| x.wrapping_mul(16).wrapping_add(33)).map(|x| x.wrapping_mul(17).wrapping_add(33)).map(|x| x.wrapping_mul(18).wrapping_add(33)).map(|x| x.wrapping_mul(19).wrapping_add(33)).map(|x| x.wrapping_mul(20).wrapping_add(33)).map(|x| x.wrapping_mul(21).wrapping_add(33)).map(|x| x.wrapping_mul(22).wrapping_add(33)).map(|x| x.wrapping_mul(23).wrapping_add(33)).map(|x| x.wrapping_mul(24).wrapping_add(33)).map(|x| x.wrapping_mul(25).wrapping_add(33)).map(|x| x.wrapping_mul(26).wrapping_add(33)).map(|x| x.wrapping_mul(27).wrapping_add(33)).map(|x| x.wrapping_mul(28).wrapping_add(33)).map(|x| x.wrapping_mul(29).wrapping_add(33)).map(|x| x.wrapping_mul(30).wrapping_add(33)).map(|x| x.wrapping_mul(31).wrapping_add(33)).map(|x| x.wrapping_mul(32).wrapping_add(33)).map(|x| x.wrapping_mul(33).wrapping_add(33)).map(|x| x.wrapping_mul(34).wrapping_add(33)).map(|x| x.wrapping_mul(35).wrapping_add(33)).map(|x| x.wrapping_mul(36).wrapping_add(33)).map(|x| x.wrapping_mul(37).wrapping_add(33)).map(|x| x.wrapping_mul(38).wrapping_add(33)).map(|x| x.wrapping_mul(39).wrapping_add(33)).map(|x| x.wrapping_mul(40).wrapping_add(33)).map(|x| x.wrapping_mul(41).wrapping_add(33)).map(|x| x.wrapping_mul(42).wrapping_add(33)).fold(0, u64::wrapping_add) } +pub fn busy_34() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(34)).map(|x| x.wrapping_mul(4).wrapping_add(34)).map(|x| x.wrapping_mul(5).wrapping_add(34)).map(|x| x.wrapping_mul(6).wrapping_add(34)).map(|x| x.wrapping_mul(7).wrapping_add(34)).map(|x| x.wrapping_mul(8).wrapping_add(34)).map(|x| x.wrapping_mul(9).wrapping_add(34)).map(|x| x.wrapping_mul(10).wrapping_add(34)).map(|x| x.wrapping_mul(11).wrapping_add(34)).map(|x| x.wrapping_mul(12).wrapping_add(34)).map(|x| x.wrapping_mul(13).wrapping_add(34)).map(|x| x.wrapping_mul(14).wrapping_add(34)).map(|x| x.wrapping_mul(15).wrapping_add(34)).map(|x| x.wrapping_mul(16).wrapping_add(34)).map(|x| x.wrapping_mul(17).wrapping_add(34)).map(|x| x.wrapping_mul(18).wrapping_add(34)).map(|x| x.wrapping_mul(19).wrapping_add(34)).map(|x| x.wrapping_mul(20).wrapping_add(34)).map(|x| x.wrapping_mul(21).wrapping_add(34)).map(|x| x.wrapping_mul(22).wrapping_add(34)).map(|x| x.wrapping_mul(23).wrapping_add(34)).map(|x| x.wrapping_mul(24).wrapping_add(34)).map(|x| x.wrapping_mul(25).wrapping_add(34)).map(|x| x.wrapping_mul(26).wrapping_add(34)).map(|x| x.wrapping_mul(27).wrapping_add(34)).map(|x| x.wrapping_mul(28).wrapping_add(34)).map(|x| x.wrapping_mul(29).wrapping_add(34)).map(|x| x.wrapping_mul(30).wrapping_add(34)).map(|x| x.wrapping_mul(31).wrapping_add(34)).map(|x| x.wrapping_mul(32).wrapping_add(34)).map(|x| x.wrapping_mul(33).wrapping_add(34)).map(|x| x.wrapping_mul(34).wrapping_add(34)).map(|x| x.wrapping_mul(35).wrapping_add(34)).map(|x| x.wrapping_mul(36).wrapping_add(34)).map(|x| x.wrapping_mul(37).wrapping_add(34)).map(|x| x.wrapping_mul(38).wrapping_add(34)).map(|x| x.wrapping_mul(39).wrapping_add(34)).map(|x| x.wrapping_mul(40).wrapping_add(34)).map(|x| x.wrapping_mul(41).wrapping_add(34)).map(|x| x.wrapping_mul(42).wrapping_add(34)).fold(0, u64::wrapping_add) } +pub fn busy_35() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(35)).map(|x| x.wrapping_mul(4).wrapping_add(35)).map(|x| x.wrapping_mul(5).wrapping_add(35)).map(|x| x.wrapping_mul(6).wrapping_add(35)).map(|x| x.wrapping_mul(7).wrapping_add(35)).map(|x| x.wrapping_mul(8).wrapping_add(35)).map(|x| x.wrapping_mul(9).wrapping_add(35)).map(|x| x.wrapping_mul(10).wrapping_add(35)).map(|x| x.wrapping_mul(11).wrapping_add(35)).map(|x| x.wrapping_mul(12).wrapping_add(35)).map(|x| x.wrapping_mul(13).wrapping_add(35)).map(|x| x.wrapping_mul(14).wrapping_add(35)).map(|x| x.wrapping_mul(15).wrapping_add(35)).map(|x| x.wrapping_mul(16).wrapping_add(35)).map(|x| x.wrapping_mul(17).wrapping_add(35)).map(|x| x.wrapping_mul(18).wrapping_add(35)).map(|x| x.wrapping_mul(19).wrapping_add(35)).map(|x| x.wrapping_mul(20).wrapping_add(35)).map(|x| x.wrapping_mul(21).wrapping_add(35)).map(|x| x.wrapping_mul(22).wrapping_add(35)).map(|x| x.wrapping_mul(23).wrapping_add(35)).map(|x| x.wrapping_mul(24).wrapping_add(35)).map(|x| x.wrapping_mul(25).wrapping_add(35)).map(|x| x.wrapping_mul(26).wrapping_add(35)).map(|x| x.wrapping_mul(27).wrapping_add(35)).map(|x| x.wrapping_mul(28).wrapping_add(35)).map(|x| x.wrapping_mul(29).wrapping_add(35)).map(|x| x.wrapping_mul(30).wrapping_add(35)).map(|x| x.wrapping_mul(31).wrapping_add(35)).map(|x| x.wrapping_mul(32).wrapping_add(35)).map(|x| x.wrapping_mul(33).wrapping_add(35)).map(|x| x.wrapping_mul(34).wrapping_add(35)).map(|x| x.wrapping_mul(35).wrapping_add(35)).map(|x| x.wrapping_mul(36).wrapping_add(35)).map(|x| x.wrapping_mul(37).wrapping_add(35)).map(|x| x.wrapping_mul(38).wrapping_add(35)).map(|x| x.wrapping_mul(39).wrapping_add(35)).map(|x| x.wrapping_mul(40).wrapping_add(35)).map(|x| x.wrapping_mul(41).wrapping_add(35)).map(|x| x.wrapping_mul(42).wrapping_add(35)).fold(0, u64::wrapping_add) } +pub fn busy_36() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(36)).map(|x| x.wrapping_mul(4).wrapping_add(36)).map(|x| x.wrapping_mul(5).wrapping_add(36)).map(|x| x.wrapping_mul(6).wrapping_add(36)).map(|x| x.wrapping_mul(7).wrapping_add(36)).map(|x| x.wrapping_mul(8).wrapping_add(36)).map(|x| x.wrapping_mul(9).wrapping_add(36)).map(|x| x.wrapping_mul(10).wrapping_add(36)).map(|x| x.wrapping_mul(11).wrapping_add(36)).map(|x| x.wrapping_mul(12).wrapping_add(36)).map(|x| x.wrapping_mul(13).wrapping_add(36)).map(|x| x.wrapping_mul(14).wrapping_add(36)).map(|x| x.wrapping_mul(15).wrapping_add(36)).map(|x| x.wrapping_mul(16).wrapping_add(36)).map(|x| x.wrapping_mul(17).wrapping_add(36)).map(|x| x.wrapping_mul(18).wrapping_add(36)).map(|x| x.wrapping_mul(19).wrapping_add(36)).map(|x| x.wrapping_mul(20).wrapping_add(36)).map(|x| x.wrapping_mul(21).wrapping_add(36)).map(|x| x.wrapping_mul(22).wrapping_add(36)).map(|x| x.wrapping_mul(23).wrapping_add(36)).map(|x| x.wrapping_mul(24).wrapping_add(36)).map(|x| x.wrapping_mul(25).wrapping_add(36)).map(|x| x.wrapping_mul(26).wrapping_add(36)).map(|x| x.wrapping_mul(27).wrapping_add(36)).map(|x| x.wrapping_mul(28).wrapping_add(36)).map(|x| x.wrapping_mul(29).wrapping_add(36)).map(|x| x.wrapping_mul(30).wrapping_add(36)).map(|x| x.wrapping_mul(31).wrapping_add(36)).map(|x| x.wrapping_mul(32).wrapping_add(36)).map(|x| x.wrapping_mul(33).wrapping_add(36)).map(|x| x.wrapping_mul(34).wrapping_add(36)).map(|x| x.wrapping_mul(35).wrapping_add(36)).map(|x| x.wrapping_mul(36).wrapping_add(36)).map(|x| x.wrapping_mul(37).wrapping_add(36)).map(|x| x.wrapping_mul(38).wrapping_add(36)).map(|x| x.wrapping_mul(39).wrapping_add(36)).map(|x| x.wrapping_mul(40).wrapping_add(36)).map(|x| x.wrapping_mul(41).wrapping_add(36)).map(|x| x.wrapping_mul(42).wrapping_add(36)).fold(0, u64::wrapping_add) } +pub fn busy_37() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(37)).map(|x| x.wrapping_mul(4).wrapping_add(37)).map(|x| x.wrapping_mul(5).wrapping_add(37)).map(|x| x.wrapping_mul(6).wrapping_add(37)).map(|x| x.wrapping_mul(7).wrapping_add(37)).map(|x| x.wrapping_mul(8).wrapping_add(37)).map(|x| x.wrapping_mul(9).wrapping_add(37)).map(|x| x.wrapping_mul(10).wrapping_add(37)).map(|x| x.wrapping_mul(11).wrapping_add(37)).map(|x| x.wrapping_mul(12).wrapping_add(37)).map(|x| x.wrapping_mul(13).wrapping_add(37)).map(|x| x.wrapping_mul(14).wrapping_add(37)).map(|x| x.wrapping_mul(15).wrapping_add(37)).map(|x| x.wrapping_mul(16).wrapping_add(37)).map(|x| x.wrapping_mul(17).wrapping_add(37)).map(|x| x.wrapping_mul(18).wrapping_add(37)).map(|x| x.wrapping_mul(19).wrapping_add(37)).map(|x| x.wrapping_mul(20).wrapping_add(37)).map(|x| x.wrapping_mul(21).wrapping_add(37)).map(|x| x.wrapping_mul(22).wrapping_add(37)).map(|x| x.wrapping_mul(23).wrapping_add(37)).map(|x| x.wrapping_mul(24).wrapping_add(37)).map(|x| x.wrapping_mul(25).wrapping_add(37)).map(|x| x.wrapping_mul(26).wrapping_add(37)).map(|x| x.wrapping_mul(27).wrapping_add(37)).map(|x| x.wrapping_mul(28).wrapping_add(37)).map(|x| x.wrapping_mul(29).wrapping_add(37)).map(|x| x.wrapping_mul(30).wrapping_add(37)).map(|x| x.wrapping_mul(31).wrapping_add(37)).map(|x| x.wrapping_mul(32).wrapping_add(37)).map(|x| x.wrapping_mul(33).wrapping_add(37)).map(|x| x.wrapping_mul(34).wrapping_add(37)).map(|x| x.wrapping_mul(35).wrapping_add(37)).map(|x| x.wrapping_mul(36).wrapping_add(37)).map(|x| x.wrapping_mul(37).wrapping_add(37)).map(|x| x.wrapping_mul(38).wrapping_add(37)).map(|x| x.wrapping_mul(39).wrapping_add(37)).map(|x| x.wrapping_mul(40).wrapping_add(37)).map(|x| x.wrapping_mul(41).wrapping_add(37)).map(|x| x.wrapping_mul(42).wrapping_add(37)).fold(0, u64::wrapping_add) } +pub fn busy_38() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(38)).map(|x| x.wrapping_mul(4).wrapping_add(38)).map(|x| x.wrapping_mul(5).wrapping_add(38)).map(|x| x.wrapping_mul(6).wrapping_add(38)).map(|x| x.wrapping_mul(7).wrapping_add(38)).map(|x| x.wrapping_mul(8).wrapping_add(38)).map(|x| x.wrapping_mul(9).wrapping_add(38)).map(|x| x.wrapping_mul(10).wrapping_add(38)).map(|x| x.wrapping_mul(11).wrapping_add(38)).map(|x| x.wrapping_mul(12).wrapping_add(38)).map(|x| x.wrapping_mul(13).wrapping_add(38)).map(|x| x.wrapping_mul(14).wrapping_add(38)).map(|x| x.wrapping_mul(15).wrapping_add(38)).map(|x| x.wrapping_mul(16).wrapping_add(38)).map(|x| x.wrapping_mul(17).wrapping_add(38)).map(|x| x.wrapping_mul(18).wrapping_add(38)).map(|x| x.wrapping_mul(19).wrapping_add(38)).map(|x| x.wrapping_mul(20).wrapping_add(38)).map(|x| x.wrapping_mul(21).wrapping_add(38)).map(|x| x.wrapping_mul(22).wrapping_add(38)).map(|x| x.wrapping_mul(23).wrapping_add(38)).map(|x| x.wrapping_mul(24).wrapping_add(38)).map(|x| x.wrapping_mul(25).wrapping_add(38)).map(|x| x.wrapping_mul(26).wrapping_add(38)).map(|x| x.wrapping_mul(27).wrapping_add(38)).map(|x| x.wrapping_mul(28).wrapping_add(38)).map(|x| x.wrapping_mul(29).wrapping_add(38)).map(|x| x.wrapping_mul(30).wrapping_add(38)).map(|x| x.wrapping_mul(31).wrapping_add(38)).map(|x| x.wrapping_mul(32).wrapping_add(38)).map(|x| x.wrapping_mul(33).wrapping_add(38)).map(|x| x.wrapping_mul(34).wrapping_add(38)).map(|x| x.wrapping_mul(35).wrapping_add(38)).map(|x| x.wrapping_mul(36).wrapping_add(38)).map(|x| x.wrapping_mul(37).wrapping_add(38)).map(|x| x.wrapping_mul(38).wrapping_add(38)).map(|x| x.wrapping_mul(39).wrapping_add(38)).map(|x| x.wrapping_mul(40).wrapping_add(38)).map(|x| x.wrapping_mul(41).wrapping_add(38)).map(|x| x.wrapping_mul(42).wrapping_add(38)).fold(0, u64::wrapping_add) } +pub fn busy_39() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(39)).map(|x| x.wrapping_mul(4).wrapping_add(39)).map(|x| x.wrapping_mul(5).wrapping_add(39)).map(|x| x.wrapping_mul(6).wrapping_add(39)).map(|x| x.wrapping_mul(7).wrapping_add(39)).map(|x| x.wrapping_mul(8).wrapping_add(39)).map(|x| x.wrapping_mul(9).wrapping_add(39)).map(|x| x.wrapping_mul(10).wrapping_add(39)).map(|x| x.wrapping_mul(11).wrapping_add(39)).map(|x| x.wrapping_mul(12).wrapping_add(39)).map(|x| x.wrapping_mul(13).wrapping_add(39)).map(|x| x.wrapping_mul(14).wrapping_add(39)).map(|x| x.wrapping_mul(15).wrapping_add(39)).map(|x| x.wrapping_mul(16).wrapping_add(39)).map(|x| x.wrapping_mul(17).wrapping_add(39)).map(|x| x.wrapping_mul(18).wrapping_add(39)).map(|x| x.wrapping_mul(19).wrapping_add(39)).map(|x| x.wrapping_mul(20).wrapping_add(39)).map(|x| x.wrapping_mul(21).wrapping_add(39)).map(|x| x.wrapping_mul(22).wrapping_add(39)).map(|x| x.wrapping_mul(23).wrapping_add(39)).map(|x| x.wrapping_mul(24).wrapping_add(39)).map(|x| x.wrapping_mul(25).wrapping_add(39)).map(|x| x.wrapping_mul(26).wrapping_add(39)).map(|x| x.wrapping_mul(27).wrapping_add(39)).map(|x| x.wrapping_mul(28).wrapping_add(39)).map(|x| x.wrapping_mul(29).wrapping_add(39)).map(|x| x.wrapping_mul(30).wrapping_add(39)).map(|x| x.wrapping_mul(31).wrapping_add(39)).map(|x| x.wrapping_mul(32).wrapping_add(39)).map(|x| x.wrapping_mul(33).wrapping_add(39)).map(|x| x.wrapping_mul(34).wrapping_add(39)).map(|x| x.wrapping_mul(35).wrapping_add(39)).map(|x| x.wrapping_mul(36).wrapping_add(39)).map(|x| x.wrapping_mul(37).wrapping_add(39)).map(|x| x.wrapping_mul(38).wrapping_add(39)).map(|x| x.wrapping_mul(39).wrapping_add(39)).map(|x| x.wrapping_mul(40).wrapping_add(39)).map(|x| x.wrapping_mul(41).wrapping_add(39)).map(|x| x.wrapping_mul(42).wrapping_add(39)).fold(0, u64::wrapping_add) } +pub fn busy_40() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(40)).map(|x| x.wrapping_mul(4).wrapping_add(40)).map(|x| x.wrapping_mul(5).wrapping_add(40)).map(|x| x.wrapping_mul(6).wrapping_add(40)).map(|x| x.wrapping_mul(7).wrapping_add(40)).map(|x| x.wrapping_mul(8).wrapping_add(40)).map(|x| x.wrapping_mul(9).wrapping_add(40)).map(|x| x.wrapping_mul(10).wrapping_add(40)).map(|x| x.wrapping_mul(11).wrapping_add(40)).map(|x| x.wrapping_mul(12).wrapping_add(40)).map(|x| x.wrapping_mul(13).wrapping_add(40)).map(|x| x.wrapping_mul(14).wrapping_add(40)).map(|x| x.wrapping_mul(15).wrapping_add(40)).map(|x| x.wrapping_mul(16).wrapping_add(40)).map(|x| x.wrapping_mul(17).wrapping_add(40)).map(|x| x.wrapping_mul(18).wrapping_add(40)).map(|x| x.wrapping_mul(19).wrapping_add(40)).map(|x| x.wrapping_mul(20).wrapping_add(40)).map(|x| x.wrapping_mul(21).wrapping_add(40)).map(|x| x.wrapping_mul(22).wrapping_add(40)).map(|x| x.wrapping_mul(23).wrapping_add(40)).map(|x| x.wrapping_mul(24).wrapping_add(40)).map(|x| x.wrapping_mul(25).wrapping_add(40)).map(|x| x.wrapping_mul(26).wrapping_add(40)).map(|x| x.wrapping_mul(27).wrapping_add(40)).map(|x| x.wrapping_mul(28).wrapping_add(40)).map(|x| x.wrapping_mul(29).wrapping_add(40)).map(|x| x.wrapping_mul(30).wrapping_add(40)).map(|x| x.wrapping_mul(31).wrapping_add(40)).map(|x| x.wrapping_mul(32).wrapping_add(40)).map(|x| x.wrapping_mul(33).wrapping_add(40)).map(|x| x.wrapping_mul(34).wrapping_add(40)).map(|x| x.wrapping_mul(35).wrapping_add(40)).map(|x| x.wrapping_mul(36).wrapping_add(40)).map(|x| x.wrapping_mul(37).wrapping_add(40)).map(|x| x.wrapping_mul(38).wrapping_add(40)).map(|x| x.wrapping_mul(39).wrapping_add(40)).map(|x| x.wrapping_mul(40).wrapping_add(40)).map(|x| x.wrapping_mul(41).wrapping_add(40)).map(|x| x.wrapping_mul(42).wrapping_add(40)).fold(0, u64::wrapping_add) } +pub fn busy_41() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(41)).map(|x| x.wrapping_mul(4).wrapping_add(41)).map(|x| x.wrapping_mul(5).wrapping_add(41)).map(|x| x.wrapping_mul(6).wrapping_add(41)).map(|x| x.wrapping_mul(7).wrapping_add(41)).map(|x| x.wrapping_mul(8).wrapping_add(41)).map(|x| x.wrapping_mul(9).wrapping_add(41)).map(|x| x.wrapping_mul(10).wrapping_add(41)).map(|x| x.wrapping_mul(11).wrapping_add(41)).map(|x| x.wrapping_mul(12).wrapping_add(41)).map(|x| x.wrapping_mul(13).wrapping_add(41)).map(|x| x.wrapping_mul(14).wrapping_add(41)).map(|x| x.wrapping_mul(15).wrapping_add(41)).map(|x| x.wrapping_mul(16).wrapping_add(41)).map(|x| x.wrapping_mul(17).wrapping_add(41)).map(|x| x.wrapping_mul(18).wrapping_add(41)).map(|x| x.wrapping_mul(19).wrapping_add(41)).map(|x| x.wrapping_mul(20).wrapping_add(41)).map(|x| x.wrapping_mul(21).wrapping_add(41)).map(|x| x.wrapping_mul(22).wrapping_add(41)).map(|x| x.wrapping_mul(23).wrapping_add(41)).map(|x| x.wrapping_mul(24).wrapping_add(41)).map(|x| x.wrapping_mul(25).wrapping_add(41)).map(|x| x.wrapping_mul(26).wrapping_add(41)).map(|x| x.wrapping_mul(27).wrapping_add(41)).map(|x| x.wrapping_mul(28).wrapping_add(41)).map(|x| x.wrapping_mul(29).wrapping_add(41)).map(|x| x.wrapping_mul(30).wrapping_add(41)).map(|x| x.wrapping_mul(31).wrapping_add(41)).map(|x| x.wrapping_mul(32).wrapping_add(41)).map(|x| x.wrapping_mul(33).wrapping_add(41)).map(|x| x.wrapping_mul(34).wrapping_add(41)).map(|x| x.wrapping_mul(35).wrapping_add(41)).map(|x| x.wrapping_mul(36).wrapping_add(41)).map(|x| x.wrapping_mul(37).wrapping_add(41)).map(|x| x.wrapping_mul(38).wrapping_add(41)).map(|x| x.wrapping_mul(39).wrapping_add(41)).map(|x| x.wrapping_mul(40).wrapping_add(41)).map(|x| x.wrapping_mul(41).wrapping_add(41)).map(|x| x.wrapping_mul(42).wrapping_add(41)).fold(0, u64::wrapping_add) } +pub fn busy_42() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(42)).map(|x| x.wrapping_mul(4).wrapping_add(42)).map(|x| x.wrapping_mul(5).wrapping_add(42)).map(|x| x.wrapping_mul(6).wrapping_add(42)).map(|x| x.wrapping_mul(7).wrapping_add(42)).map(|x| x.wrapping_mul(8).wrapping_add(42)).map(|x| x.wrapping_mul(9).wrapping_add(42)).map(|x| x.wrapping_mul(10).wrapping_add(42)).map(|x| x.wrapping_mul(11).wrapping_add(42)).map(|x| x.wrapping_mul(12).wrapping_add(42)).map(|x| x.wrapping_mul(13).wrapping_add(42)).map(|x| x.wrapping_mul(14).wrapping_add(42)).map(|x| x.wrapping_mul(15).wrapping_add(42)).map(|x| x.wrapping_mul(16).wrapping_add(42)).map(|x| x.wrapping_mul(17).wrapping_add(42)).map(|x| x.wrapping_mul(18).wrapping_add(42)).map(|x| x.wrapping_mul(19).wrapping_add(42)).map(|x| x.wrapping_mul(20).wrapping_add(42)).map(|x| x.wrapping_mul(21).wrapping_add(42)).map(|x| x.wrapping_mul(22).wrapping_add(42)).map(|x| x.wrapping_mul(23).wrapping_add(42)).map(|x| x.wrapping_mul(24).wrapping_add(42)).map(|x| x.wrapping_mul(25).wrapping_add(42)).map(|x| x.wrapping_mul(26).wrapping_add(42)).map(|x| x.wrapping_mul(27).wrapping_add(42)).map(|x| x.wrapping_mul(28).wrapping_add(42)).map(|x| x.wrapping_mul(29).wrapping_add(42)).map(|x| x.wrapping_mul(30).wrapping_add(42)).map(|x| x.wrapping_mul(31).wrapping_add(42)).map(|x| x.wrapping_mul(32).wrapping_add(42)).map(|x| x.wrapping_mul(33).wrapping_add(42)).map(|x| x.wrapping_mul(34).wrapping_add(42)).map(|x| x.wrapping_mul(35).wrapping_add(42)).map(|x| x.wrapping_mul(36).wrapping_add(42)).map(|x| x.wrapping_mul(37).wrapping_add(42)).map(|x| x.wrapping_mul(38).wrapping_add(42)).map(|x| x.wrapping_mul(39).wrapping_add(42)).map(|x| x.wrapping_mul(40).wrapping_add(42)).map(|x| x.wrapping_mul(41).wrapping_add(42)).map(|x| x.wrapping_mul(42).wrapping_add(42)).fold(0, u64::wrapping_add) } +pub fn busy_43() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(43)).map(|x| x.wrapping_mul(4).wrapping_add(43)).map(|x| x.wrapping_mul(5).wrapping_add(43)).map(|x| x.wrapping_mul(6).wrapping_add(43)).map(|x| x.wrapping_mul(7).wrapping_add(43)).map(|x| x.wrapping_mul(8).wrapping_add(43)).map(|x| x.wrapping_mul(9).wrapping_add(43)).map(|x| x.wrapping_mul(10).wrapping_add(43)).map(|x| x.wrapping_mul(11).wrapping_add(43)).map(|x| x.wrapping_mul(12).wrapping_add(43)).map(|x| x.wrapping_mul(13).wrapping_add(43)).map(|x| x.wrapping_mul(14).wrapping_add(43)).map(|x| x.wrapping_mul(15).wrapping_add(43)).map(|x| x.wrapping_mul(16).wrapping_add(43)).map(|x| x.wrapping_mul(17).wrapping_add(43)).map(|x| x.wrapping_mul(18).wrapping_add(43)).map(|x| x.wrapping_mul(19).wrapping_add(43)).map(|x| x.wrapping_mul(20).wrapping_add(43)).map(|x| x.wrapping_mul(21).wrapping_add(43)).map(|x| x.wrapping_mul(22).wrapping_add(43)).map(|x| x.wrapping_mul(23).wrapping_add(43)).map(|x| x.wrapping_mul(24).wrapping_add(43)).map(|x| x.wrapping_mul(25).wrapping_add(43)).map(|x| x.wrapping_mul(26).wrapping_add(43)).map(|x| x.wrapping_mul(27).wrapping_add(43)).map(|x| x.wrapping_mul(28).wrapping_add(43)).map(|x| x.wrapping_mul(29).wrapping_add(43)).map(|x| x.wrapping_mul(30).wrapping_add(43)).map(|x| x.wrapping_mul(31).wrapping_add(43)).map(|x| x.wrapping_mul(32).wrapping_add(43)).map(|x| x.wrapping_mul(33).wrapping_add(43)).map(|x| x.wrapping_mul(34).wrapping_add(43)).map(|x| x.wrapping_mul(35).wrapping_add(43)).map(|x| x.wrapping_mul(36).wrapping_add(43)).map(|x| x.wrapping_mul(37).wrapping_add(43)).map(|x| x.wrapping_mul(38).wrapping_add(43)).map(|x| x.wrapping_mul(39).wrapping_add(43)).map(|x| x.wrapping_mul(40).wrapping_add(43)).map(|x| x.wrapping_mul(41).wrapping_add(43)).map(|x| x.wrapping_mul(42).wrapping_add(43)).fold(0, u64::wrapping_add) } +pub fn busy_44() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(44)).map(|x| x.wrapping_mul(4).wrapping_add(44)).map(|x| x.wrapping_mul(5).wrapping_add(44)).map(|x| x.wrapping_mul(6).wrapping_add(44)).map(|x| x.wrapping_mul(7).wrapping_add(44)).map(|x| x.wrapping_mul(8).wrapping_add(44)).map(|x| x.wrapping_mul(9).wrapping_add(44)).map(|x| x.wrapping_mul(10).wrapping_add(44)).map(|x| x.wrapping_mul(11).wrapping_add(44)).map(|x| x.wrapping_mul(12).wrapping_add(44)).map(|x| x.wrapping_mul(13).wrapping_add(44)).map(|x| x.wrapping_mul(14).wrapping_add(44)).map(|x| x.wrapping_mul(15).wrapping_add(44)).map(|x| x.wrapping_mul(16).wrapping_add(44)).map(|x| x.wrapping_mul(17).wrapping_add(44)).map(|x| x.wrapping_mul(18).wrapping_add(44)).map(|x| x.wrapping_mul(19).wrapping_add(44)).map(|x| x.wrapping_mul(20).wrapping_add(44)).map(|x| x.wrapping_mul(21).wrapping_add(44)).map(|x| x.wrapping_mul(22).wrapping_add(44)).map(|x| x.wrapping_mul(23).wrapping_add(44)).map(|x| x.wrapping_mul(24).wrapping_add(44)).map(|x| x.wrapping_mul(25).wrapping_add(44)).map(|x| x.wrapping_mul(26).wrapping_add(44)).map(|x| x.wrapping_mul(27).wrapping_add(44)).map(|x| x.wrapping_mul(28).wrapping_add(44)).map(|x| x.wrapping_mul(29).wrapping_add(44)).map(|x| x.wrapping_mul(30).wrapping_add(44)).map(|x| x.wrapping_mul(31).wrapping_add(44)).map(|x| x.wrapping_mul(32).wrapping_add(44)).map(|x| x.wrapping_mul(33).wrapping_add(44)).map(|x| x.wrapping_mul(34).wrapping_add(44)).map(|x| x.wrapping_mul(35).wrapping_add(44)).map(|x| x.wrapping_mul(36).wrapping_add(44)).map(|x| x.wrapping_mul(37).wrapping_add(44)).map(|x| x.wrapping_mul(38).wrapping_add(44)).map(|x| x.wrapping_mul(39).wrapping_add(44)).map(|x| x.wrapping_mul(40).wrapping_add(44)).map(|x| x.wrapping_mul(41).wrapping_add(44)).map(|x| x.wrapping_mul(42).wrapping_add(44)).fold(0, u64::wrapping_add) } +pub fn busy_45() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(45)).map(|x| x.wrapping_mul(4).wrapping_add(45)).map(|x| x.wrapping_mul(5).wrapping_add(45)).map(|x| x.wrapping_mul(6).wrapping_add(45)).map(|x| x.wrapping_mul(7).wrapping_add(45)).map(|x| x.wrapping_mul(8).wrapping_add(45)).map(|x| x.wrapping_mul(9).wrapping_add(45)).map(|x| x.wrapping_mul(10).wrapping_add(45)).map(|x| x.wrapping_mul(11).wrapping_add(45)).map(|x| x.wrapping_mul(12).wrapping_add(45)).map(|x| x.wrapping_mul(13).wrapping_add(45)).map(|x| x.wrapping_mul(14).wrapping_add(45)).map(|x| x.wrapping_mul(15).wrapping_add(45)).map(|x| x.wrapping_mul(16).wrapping_add(45)).map(|x| x.wrapping_mul(17).wrapping_add(45)).map(|x| x.wrapping_mul(18).wrapping_add(45)).map(|x| x.wrapping_mul(19).wrapping_add(45)).map(|x| x.wrapping_mul(20).wrapping_add(45)).map(|x| x.wrapping_mul(21).wrapping_add(45)).map(|x| x.wrapping_mul(22).wrapping_add(45)).map(|x| x.wrapping_mul(23).wrapping_add(45)).map(|x| x.wrapping_mul(24).wrapping_add(45)).map(|x| x.wrapping_mul(25).wrapping_add(45)).map(|x| x.wrapping_mul(26).wrapping_add(45)).map(|x| x.wrapping_mul(27).wrapping_add(45)).map(|x| x.wrapping_mul(28).wrapping_add(45)).map(|x| x.wrapping_mul(29).wrapping_add(45)).map(|x| x.wrapping_mul(30).wrapping_add(45)).map(|x| x.wrapping_mul(31).wrapping_add(45)).map(|x| x.wrapping_mul(32).wrapping_add(45)).map(|x| x.wrapping_mul(33).wrapping_add(45)).map(|x| x.wrapping_mul(34).wrapping_add(45)).map(|x| x.wrapping_mul(35).wrapping_add(45)).map(|x| x.wrapping_mul(36).wrapping_add(45)).map(|x| x.wrapping_mul(37).wrapping_add(45)).map(|x| x.wrapping_mul(38).wrapping_add(45)).map(|x| x.wrapping_mul(39).wrapping_add(45)).map(|x| x.wrapping_mul(40).wrapping_add(45)).map(|x| x.wrapping_mul(41).wrapping_add(45)).map(|x| x.wrapping_mul(42).wrapping_add(45)).fold(0, u64::wrapping_add) } +pub fn busy_46() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(46)).map(|x| x.wrapping_mul(4).wrapping_add(46)).map(|x| x.wrapping_mul(5).wrapping_add(46)).map(|x| x.wrapping_mul(6).wrapping_add(46)).map(|x| x.wrapping_mul(7).wrapping_add(46)).map(|x| x.wrapping_mul(8).wrapping_add(46)).map(|x| x.wrapping_mul(9).wrapping_add(46)).map(|x| x.wrapping_mul(10).wrapping_add(46)).map(|x| x.wrapping_mul(11).wrapping_add(46)).map(|x| x.wrapping_mul(12).wrapping_add(46)).map(|x| x.wrapping_mul(13).wrapping_add(46)).map(|x| x.wrapping_mul(14).wrapping_add(46)).map(|x| x.wrapping_mul(15).wrapping_add(46)).map(|x| x.wrapping_mul(16).wrapping_add(46)).map(|x| x.wrapping_mul(17).wrapping_add(46)).map(|x| x.wrapping_mul(18).wrapping_add(46)).map(|x| x.wrapping_mul(19).wrapping_add(46)).map(|x| x.wrapping_mul(20).wrapping_add(46)).map(|x| x.wrapping_mul(21).wrapping_add(46)).map(|x| x.wrapping_mul(22).wrapping_add(46)).map(|x| x.wrapping_mul(23).wrapping_add(46)).map(|x| x.wrapping_mul(24).wrapping_add(46)).map(|x| x.wrapping_mul(25).wrapping_add(46)).map(|x| x.wrapping_mul(26).wrapping_add(46)).map(|x| x.wrapping_mul(27).wrapping_add(46)).map(|x| x.wrapping_mul(28).wrapping_add(46)).map(|x| x.wrapping_mul(29).wrapping_add(46)).map(|x| x.wrapping_mul(30).wrapping_add(46)).map(|x| x.wrapping_mul(31).wrapping_add(46)).map(|x| x.wrapping_mul(32).wrapping_add(46)).map(|x| x.wrapping_mul(33).wrapping_add(46)).map(|x| x.wrapping_mul(34).wrapping_add(46)).map(|x| x.wrapping_mul(35).wrapping_add(46)).map(|x| x.wrapping_mul(36).wrapping_add(46)).map(|x| x.wrapping_mul(37).wrapping_add(46)).map(|x| x.wrapping_mul(38).wrapping_add(46)).map(|x| x.wrapping_mul(39).wrapping_add(46)).map(|x| x.wrapping_mul(40).wrapping_add(46)).map(|x| x.wrapping_mul(41).wrapping_add(46)).map(|x| x.wrapping_mul(42).wrapping_add(46)).fold(0, u64::wrapping_add) } +pub fn busy_47() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(47)).map(|x| x.wrapping_mul(4).wrapping_add(47)).map(|x| x.wrapping_mul(5).wrapping_add(47)).map(|x| x.wrapping_mul(6).wrapping_add(47)).map(|x| x.wrapping_mul(7).wrapping_add(47)).map(|x| x.wrapping_mul(8).wrapping_add(47)).map(|x| x.wrapping_mul(9).wrapping_add(47)).map(|x| x.wrapping_mul(10).wrapping_add(47)).map(|x| x.wrapping_mul(11).wrapping_add(47)).map(|x| x.wrapping_mul(12).wrapping_add(47)).map(|x| x.wrapping_mul(13).wrapping_add(47)).map(|x| x.wrapping_mul(14).wrapping_add(47)).map(|x| x.wrapping_mul(15).wrapping_add(47)).map(|x| x.wrapping_mul(16).wrapping_add(47)).map(|x| x.wrapping_mul(17).wrapping_add(47)).map(|x| x.wrapping_mul(18).wrapping_add(47)).map(|x| x.wrapping_mul(19).wrapping_add(47)).map(|x| x.wrapping_mul(20).wrapping_add(47)).map(|x| x.wrapping_mul(21).wrapping_add(47)).map(|x| x.wrapping_mul(22).wrapping_add(47)).map(|x| x.wrapping_mul(23).wrapping_add(47)).map(|x| x.wrapping_mul(24).wrapping_add(47)).map(|x| x.wrapping_mul(25).wrapping_add(47)).map(|x| x.wrapping_mul(26).wrapping_add(47)).map(|x| x.wrapping_mul(27).wrapping_add(47)).map(|x| x.wrapping_mul(28).wrapping_add(47)).map(|x| x.wrapping_mul(29).wrapping_add(47)).map(|x| x.wrapping_mul(30).wrapping_add(47)).map(|x| x.wrapping_mul(31).wrapping_add(47)).map(|x| x.wrapping_mul(32).wrapping_add(47)).map(|x| x.wrapping_mul(33).wrapping_add(47)).map(|x| x.wrapping_mul(34).wrapping_add(47)).map(|x| x.wrapping_mul(35).wrapping_add(47)).map(|x| x.wrapping_mul(36).wrapping_add(47)).map(|x| x.wrapping_mul(37).wrapping_add(47)).map(|x| x.wrapping_mul(38).wrapping_add(47)).map(|x| x.wrapping_mul(39).wrapping_add(47)).map(|x| x.wrapping_mul(40).wrapping_add(47)).map(|x| x.wrapping_mul(41).wrapping_add(47)).map(|x| x.wrapping_mul(42).wrapping_add(47)).fold(0, u64::wrapping_add) } +pub fn busy_48() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(48)).map(|x| x.wrapping_mul(4).wrapping_add(48)).map(|x| x.wrapping_mul(5).wrapping_add(48)).map(|x| x.wrapping_mul(6).wrapping_add(48)).map(|x| x.wrapping_mul(7).wrapping_add(48)).map(|x| x.wrapping_mul(8).wrapping_add(48)).map(|x| x.wrapping_mul(9).wrapping_add(48)).map(|x| x.wrapping_mul(10).wrapping_add(48)).map(|x| x.wrapping_mul(11).wrapping_add(48)).map(|x| x.wrapping_mul(12).wrapping_add(48)).map(|x| x.wrapping_mul(13).wrapping_add(48)).map(|x| x.wrapping_mul(14).wrapping_add(48)).map(|x| x.wrapping_mul(15).wrapping_add(48)).map(|x| x.wrapping_mul(16).wrapping_add(48)).map(|x| x.wrapping_mul(17).wrapping_add(48)).map(|x| x.wrapping_mul(18).wrapping_add(48)).map(|x| x.wrapping_mul(19).wrapping_add(48)).map(|x| x.wrapping_mul(20).wrapping_add(48)).map(|x| x.wrapping_mul(21).wrapping_add(48)).map(|x| x.wrapping_mul(22).wrapping_add(48)).map(|x| x.wrapping_mul(23).wrapping_add(48)).map(|x| x.wrapping_mul(24).wrapping_add(48)).map(|x| x.wrapping_mul(25).wrapping_add(48)).map(|x| x.wrapping_mul(26).wrapping_add(48)).map(|x| x.wrapping_mul(27).wrapping_add(48)).map(|x| x.wrapping_mul(28).wrapping_add(48)).map(|x| x.wrapping_mul(29).wrapping_add(48)).map(|x| x.wrapping_mul(30).wrapping_add(48)).map(|x| x.wrapping_mul(31).wrapping_add(48)).map(|x| x.wrapping_mul(32).wrapping_add(48)).map(|x| x.wrapping_mul(33).wrapping_add(48)).map(|x| x.wrapping_mul(34).wrapping_add(48)).map(|x| x.wrapping_mul(35).wrapping_add(48)).map(|x| x.wrapping_mul(36).wrapping_add(48)).map(|x| x.wrapping_mul(37).wrapping_add(48)).map(|x| x.wrapping_mul(38).wrapping_add(48)).map(|x| x.wrapping_mul(39).wrapping_add(48)).map(|x| x.wrapping_mul(40).wrapping_add(48)).map(|x| x.wrapping_mul(41).wrapping_add(48)).map(|x| x.wrapping_mul(42).wrapping_add(48)).fold(0, u64::wrapping_add) } +pub fn busy_49() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(49)).map(|x| x.wrapping_mul(4).wrapping_add(49)).map(|x| x.wrapping_mul(5).wrapping_add(49)).map(|x| x.wrapping_mul(6).wrapping_add(49)).map(|x| x.wrapping_mul(7).wrapping_add(49)).map(|x| x.wrapping_mul(8).wrapping_add(49)).map(|x| x.wrapping_mul(9).wrapping_add(49)).map(|x| x.wrapping_mul(10).wrapping_add(49)).map(|x| x.wrapping_mul(11).wrapping_add(49)).map(|x| x.wrapping_mul(12).wrapping_add(49)).map(|x| x.wrapping_mul(13).wrapping_add(49)).map(|x| x.wrapping_mul(14).wrapping_add(49)).map(|x| x.wrapping_mul(15).wrapping_add(49)).map(|x| x.wrapping_mul(16).wrapping_add(49)).map(|x| x.wrapping_mul(17).wrapping_add(49)).map(|x| x.wrapping_mul(18).wrapping_add(49)).map(|x| x.wrapping_mul(19).wrapping_add(49)).map(|x| x.wrapping_mul(20).wrapping_add(49)).map(|x| x.wrapping_mul(21).wrapping_add(49)).map(|x| x.wrapping_mul(22).wrapping_add(49)).map(|x| x.wrapping_mul(23).wrapping_add(49)).map(|x| x.wrapping_mul(24).wrapping_add(49)).map(|x| x.wrapping_mul(25).wrapping_add(49)).map(|x| x.wrapping_mul(26).wrapping_add(49)).map(|x| x.wrapping_mul(27).wrapping_add(49)).map(|x| x.wrapping_mul(28).wrapping_add(49)).map(|x| x.wrapping_mul(29).wrapping_add(49)).map(|x| x.wrapping_mul(30).wrapping_add(49)).map(|x| x.wrapping_mul(31).wrapping_add(49)).map(|x| x.wrapping_mul(32).wrapping_add(49)).map(|x| x.wrapping_mul(33).wrapping_add(49)).map(|x| x.wrapping_mul(34).wrapping_add(49)).map(|x| x.wrapping_mul(35).wrapping_add(49)).map(|x| x.wrapping_mul(36).wrapping_add(49)).map(|x| x.wrapping_mul(37).wrapping_add(49)).map(|x| x.wrapping_mul(38).wrapping_add(49)).map(|x| x.wrapping_mul(39).wrapping_add(49)).map(|x| x.wrapping_mul(40).wrapping_add(49)).map(|x| x.wrapping_mul(41).wrapping_add(49)).map(|x| x.wrapping_mul(42).wrapping_add(49)).fold(0, u64::wrapping_add) } +pub fn busy_50() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(50)).map(|x| x.wrapping_mul(4).wrapping_add(50)).map(|x| x.wrapping_mul(5).wrapping_add(50)).map(|x| x.wrapping_mul(6).wrapping_add(50)).map(|x| x.wrapping_mul(7).wrapping_add(50)).map(|x| x.wrapping_mul(8).wrapping_add(50)).map(|x| x.wrapping_mul(9).wrapping_add(50)).map(|x| x.wrapping_mul(10).wrapping_add(50)).map(|x| x.wrapping_mul(11).wrapping_add(50)).map(|x| x.wrapping_mul(12).wrapping_add(50)).map(|x| x.wrapping_mul(13).wrapping_add(50)).map(|x| x.wrapping_mul(14).wrapping_add(50)).map(|x| x.wrapping_mul(15).wrapping_add(50)).map(|x| x.wrapping_mul(16).wrapping_add(50)).map(|x| x.wrapping_mul(17).wrapping_add(50)).map(|x| x.wrapping_mul(18).wrapping_add(50)).map(|x| x.wrapping_mul(19).wrapping_add(50)).map(|x| x.wrapping_mul(20).wrapping_add(50)).map(|x| x.wrapping_mul(21).wrapping_add(50)).map(|x| x.wrapping_mul(22).wrapping_add(50)).map(|x| x.wrapping_mul(23).wrapping_add(50)).map(|x| x.wrapping_mul(24).wrapping_add(50)).map(|x| x.wrapping_mul(25).wrapping_add(50)).map(|x| x.wrapping_mul(26).wrapping_add(50)).map(|x| x.wrapping_mul(27).wrapping_add(50)).map(|x| x.wrapping_mul(28).wrapping_add(50)).map(|x| x.wrapping_mul(29).wrapping_add(50)).map(|x| x.wrapping_mul(30).wrapping_add(50)).map(|x| x.wrapping_mul(31).wrapping_add(50)).map(|x| x.wrapping_mul(32).wrapping_add(50)).map(|x| x.wrapping_mul(33).wrapping_add(50)).map(|x| x.wrapping_mul(34).wrapping_add(50)).map(|x| x.wrapping_mul(35).wrapping_add(50)).map(|x| x.wrapping_mul(36).wrapping_add(50)).map(|x| x.wrapping_mul(37).wrapping_add(50)).map(|x| x.wrapping_mul(38).wrapping_add(50)).map(|x| x.wrapping_mul(39).wrapping_add(50)).map(|x| x.wrapping_mul(40).wrapping_add(50)).map(|x| x.wrapping_mul(41).wrapping_add(50)).map(|x| x.wrapping_mul(42).wrapping_add(50)).fold(0, u64::wrapping_add) } +pub fn busy_51() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(51)).map(|x| x.wrapping_mul(4).wrapping_add(51)).map(|x| x.wrapping_mul(5).wrapping_add(51)).map(|x| x.wrapping_mul(6).wrapping_add(51)).map(|x| x.wrapping_mul(7).wrapping_add(51)).map(|x| x.wrapping_mul(8).wrapping_add(51)).map(|x| x.wrapping_mul(9).wrapping_add(51)).map(|x| x.wrapping_mul(10).wrapping_add(51)).map(|x| x.wrapping_mul(11).wrapping_add(51)).map(|x| x.wrapping_mul(12).wrapping_add(51)).map(|x| x.wrapping_mul(13).wrapping_add(51)).map(|x| x.wrapping_mul(14).wrapping_add(51)).map(|x| x.wrapping_mul(15).wrapping_add(51)).map(|x| x.wrapping_mul(16).wrapping_add(51)).map(|x| x.wrapping_mul(17).wrapping_add(51)).map(|x| x.wrapping_mul(18).wrapping_add(51)).map(|x| x.wrapping_mul(19).wrapping_add(51)).map(|x| x.wrapping_mul(20).wrapping_add(51)).map(|x| x.wrapping_mul(21).wrapping_add(51)).map(|x| x.wrapping_mul(22).wrapping_add(51)).map(|x| x.wrapping_mul(23).wrapping_add(51)).map(|x| x.wrapping_mul(24).wrapping_add(51)).map(|x| x.wrapping_mul(25).wrapping_add(51)).map(|x| x.wrapping_mul(26).wrapping_add(51)).map(|x| x.wrapping_mul(27).wrapping_add(51)).map(|x| x.wrapping_mul(28).wrapping_add(51)).map(|x| x.wrapping_mul(29).wrapping_add(51)).map(|x| x.wrapping_mul(30).wrapping_add(51)).map(|x| x.wrapping_mul(31).wrapping_add(51)).map(|x| x.wrapping_mul(32).wrapping_add(51)).map(|x| x.wrapping_mul(33).wrapping_add(51)).map(|x| x.wrapping_mul(34).wrapping_add(51)).map(|x| x.wrapping_mul(35).wrapping_add(51)).map(|x| x.wrapping_mul(36).wrapping_add(51)).map(|x| x.wrapping_mul(37).wrapping_add(51)).map(|x| x.wrapping_mul(38).wrapping_add(51)).map(|x| x.wrapping_mul(39).wrapping_add(51)).map(|x| x.wrapping_mul(40).wrapping_add(51)).map(|x| x.wrapping_mul(41).wrapping_add(51)).map(|x| x.wrapping_mul(42).wrapping_add(51)).fold(0, u64::wrapping_add) } +pub fn busy_52() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(52)).map(|x| x.wrapping_mul(4).wrapping_add(52)).map(|x| x.wrapping_mul(5).wrapping_add(52)).map(|x| x.wrapping_mul(6).wrapping_add(52)).map(|x| x.wrapping_mul(7).wrapping_add(52)).map(|x| x.wrapping_mul(8).wrapping_add(52)).map(|x| x.wrapping_mul(9).wrapping_add(52)).map(|x| x.wrapping_mul(10).wrapping_add(52)).map(|x| x.wrapping_mul(11).wrapping_add(52)).map(|x| x.wrapping_mul(12).wrapping_add(52)).map(|x| x.wrapping_mul(13).wrapping_add(52)).map(|x| x.wrapping_mul(14).wrapping_add(52)).map(|x| x.wrapping_mul(15).wrapping_add(52)).map(|x| x.wrapping_mul(16).wrapping_add(52)).map(|x| x.wrapping_mul(17).wrapping_add(52)).map(|x| x.wrapping_mul(18).wrapping_add(52)).map(|x| x.wrapping_mul(19).wrapping_add(52)).map(|x| x.wrapping_mul(20).wrapping_add(52)).map(|x| x.wrapping_mul(21).wrapping_add(52)).map(|x| x.wrapping_mul(22).wrapping_add(52)).map(|x| x.wrapping_mul(23).wrapping_add(52)).map(|x| x.wrapping_mul(24).wrapping_add(52)).map(|x| x.wrapping_mul(25).wrapping_add(52)).map(|x| x.wrapping_mul(26).wrapping_add(52)).map(|x| x.wrapping_mul(27).wrapping_add(52)).map(|x| x.wrapping_mul(28).wrapping_add(52)).map(|x| x.wrapping_mul(29).wrapping_add(52)).map(|x| x.wrapping_mul(30).wrapping_add(52)).map(|x| x.wrapping_mul(31).wrapping_add(52)).map(|x| x.wrapping_mul(32).wrapping_add(52)).map(|x| x.wrapping_mul(33).wrapping_add(52)).map(|x| x.wrapping_mul(34).wrapping_add(52)).map(|x| x.wrapping_mul(35).wrapping_add(52)).map(|x| x.wrapping_mul(36).wrapping_add(52)).map(|x| x.wrapping_mul(37).wrapping_add(52)).map(|x| x.wrapping_mul(38).wrapping_add(52)).map(|x| x.wrapping_mul(39).wrapping_add(52)).map(|x| x.wrapping_mul(40).wrapping_add(52)).map(|x| x.wrapping_mul(41).wrapping_add(52)).map(|x| x.wrapping_mul(42).wrapping_add(52)).fold(0, u64::wrapping_add) } +pub fn busy_53() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(53)).map(|x| x.wrapping_mul(4).wrapping_add(53)).map(|x| x.wrapping_mul(5).wrapping_add(53)).map(|x| x.wrapping_mul(6).wrapping_add(53)).map(|x| x.wrapping_mul(7).wrapping_add(53)).map(|x| x.wrapping_mul(8).wrapping_add(53)).map(|x| x.wrapping_mul(9).wrapping_add(53)).map(|x| x.wrapping_mul(10).wrapping_add(53)).map(|x| x.wrapping_mul(11).wrapping_add(53)).map(|x| x.wrapping_mul(12).wrapping_add(53)).map(|x| x.wrapping_mul(13).wrapping_add(53)).map(|x| x.wrapping_mul(14).wrapping_add(53)).map(|x| x.wrapping_mul(15).wrapping_add(53)).map(|x| x.wrapping_mul(16).wrapping_add(53)).map(|x| x.wrapping_mul(17).wrapping_add(53)).map(|x| x.wrapping_mul(18).wrapping_add(53)).map(|x| x.wrapping_mul(19).wrapping_add(53)).map(|x| x.wrapping_mul(20).wrapping_add(53)).map(|x| x.wrapping_mul(21).wrapping_add(53)).map(|x| x.wrapping_mul(22).wrapping_add(53)).map(|x| x.wrapping_mul(23).wrapping_add(53)).map(|x| x.wrapping_mul(24).wrapping_add(53)).map(|x| x.wrapping_mul(25).wrapping_add(53)).map(|x| x.wrapping_mul(26).wrapping_add(53)).map(|x| x.wrapping_mul(27).wrapping_add(53)).map(|x| x.wrapping_mul(28).wrapping_add(53)).map(|x| x.wrapping_mul(29).wrapping_add(53)).map(|x| x.wrapping_mul(30).wrapping_add(53)).map(|x| x.wrapping_mul(31).wrapping_add(53)).map(|x| x.wrapping_mul(32).wrapping_add(53)).map(|x| x.wrapping_mul(33).wrapping_add(53)).map(|x| x.wrapping_mul(34).wrapping_add(53)).map(|x| x.wrapping_mul(35).wrapping_add(53)).map(|x| x.wrapping_mul(36).wrapping_add(53)).map(|x| x.wrapping_mul(37).wrapping_add(53)).map(|x| x.wrapping_mul(38).wrapping_add(53)).map(|x| x.wrapping_mul(39).wrapping_add(53)).map(|x| x.wrapping_mul(40).wrapping_add(53)).map(|x| x.wrapping_mul(41).wrapping_add(53)).map(|x| x.wrapping_mul(42).wrapping_add(53)).fold(0, u64::wrapping_add) } +pub fn busy_54() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(54)).map(|x| x.wrapping_mul(4).wrapping_add(54)).map(|x| x.wrapping_mul(5).wrapping_add(54)).map(|x| x.wrapping_mul(6).wrapping_add(54)).map(|x| x.wrapping_mul(7).wrapping_add(54)).map(|x| x.wrapping_mul(8).wrapping_add(54)).map(|x| x.wrapping_mul(9).wrapping_add(54)).map(|x| x.wrapping_mul(10).wrapping_add(54)).map(|x| x.wrapping_mul(11).wrapping_add(54)).map(|x| x.wrapping_mul(12).wrapping_add(54)).map(|x| x.wrapping_mul(13).wrapping_add(54)).map(|x| x.wrapping_mul(14).wrapping_add(54)).map(|x| x.wrapping_mul(15).wrapping_add(54)).map(|x| x.wrapping_mul(16).wrapping_add(54)).map(|x| x.wrapping_mul(17).wrapping_add(54)).map(|x| x.wrapping_mul(18).wrapping_add(54)).map(|x| x.wrapping_mul(19).wrapping_add(54)).map(|x| x.wrapping_mul(20).wrapping_add(54)).map(|x| x.wrapping_mul(21).wrapping_add(54)).map(|x| x.wrapping_mul(22).wrapping_add(54)).map(|x| x.wrapping_mul(23).wrapping_add(54)).map(|x| x.wrapping_mul(24).wrapping_add(54)).map(|x| x.wrapping_mul(25).wrapping_add(54)).map(|x| x.wrapping_mul(26).wrapping_add(54)).map(|x| x.wrapping_mul(27).wrapping_add(54)).map(|x| x.wrapping_mul(28).wrapping_add(54)).map(|x| x.wrapping_mul(29).wrapping_add(54)).map(|x| x.wrapping_mul(30).wrapping_add(54)).map(|x| x.wrapping_mul(31).wrapping_add(54)).map(|x| x.wrapping_mul(32).wrapping_add(54)).map(|x| x.wrapping_mul(33).wrapping_add(54)).map(|x| x.wrapping_mul(34).wrapping_add(54)).map(|x| x.wrapping_mul(35).wrapping_add(54)).map(|x| x.wrapping_mul(36).wrapping_add(54)).map(|x| x.wrapping_mul(37).wrapping_add(54)).map(|x| x.wrapping_mul(38).wrapping_add(54)).map(|x| x.wrapping_mul(39).wrapping_add(54)).map(|x| x.wrapping_mul(40).wrapping_add(54)).map(|x| x.wrapping_mul(41).wrapping_add(54)).map(|x| x.wrapping_mul(42).wrapping_add(54)).fold(0, u64::wrapping_add) } +pub fn busy_55() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(55)).map(|x| x.wrapping_mul(4).wrapping_add(55)).map(|x| x.wrapping_mul(5).wrapping_add(55)).map(|x| x.wrapping_mul(6).wrapping_add(55)).map(|x| x.wrapping_mul(7).wrapping_add(55)).map(|x| x.wrapping_mul(8).wrapping_add(55)).map(|x| x.wrapping_mul(9).wrapping_add(55)).map(|x| x.wrapping_mul(10).wrapping_add(55)).map(|x| x.wrapping_mul(11).wrapping_add(55)).map(|x| x.wrapping_mul(12).wrapping_add(55)).map(|x| x.wrapping_mul(13).wrapping_add(55)).map(|x| x.wrapping_mul(14).wrapping_add(55)).map(|x| x.wrapping_mul(15).wrapping_add(55)).map(|x| x.wrapping_mul(16).wrapping_add(55)).map(|x| x.wrapping_mul(17).wrapping_add(55)).map(|x| x.wrapping_mul(18).wrapping_add(55)).map(|x| x.wrapping_mul(19).wrapping_add(55)).map(|x| x.wrapping_mul(20).wrapping_add(55)).map(|x| x.wrapping_mul(21).wrapping_add(55)).map(|x| x.wrapping_mul(22).wrapping_add(55)).map(|x| x.wrapping_mul(23).wrapping_add(55)).map(|x| x.wrapping_mul(24).wrapping_add(55)).map(|x| x.wrapping_mul(25).wrapping_add(55)).map(|x| x.wrapping_mul(26).wrapping_add(55)).map(|x| x.wrapping_mul(27).wrapping_add(55)).map(|x| x.wrapping_mul(28).wrapping_add(55)).map(|x| x.wrapping_mul(29).wrapping_add(55)).map(|x| x.wrapping_mul(30).wrapping_add(55)).map(|x| x.wrapping_mul(31).wrapping_add(55)).map(|x| x.wrapping_mul(32).wrapping_add(55)).map(|x| x.wrapping_mul(33).wrapping_add(55)).map(|x| x.wrapping_mul(34).wrapping_add(55)).map(|x| x.wrapping_mul(35).wrapping_add(55)).map(|x| x.wrapping_mul(36).wrapping_add(55)).map(|x| x.wrapping_mul(37).wrapping_add(55)).map(|x| x.wrapping_mul(38).wrapping_add(55)).map(|x| x.wrapping_mul(39).wrapping_add(55)).map(|x| x.wrapping_mul(40).wrapping_add(55)).map(|x| x.wrapping_mul(41).wrapping_add(55)).map(|x| x.wrapping_mul(42).wrapping_add(55)).fold(0, u64::wrapping_add) } +pub fn busy_56() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(56)).map(|x| x.wrapping_mul(4).wrapping_add(56)).map(|x| x.wrapping_mul(5).wrapping_add(56)).map(|x| x.wrapping_mul(6).wrapping_add(56)).map(|x| x.wrapping_mul(7).wrapping_add(56)).map(|x| x.wrapping_mul(8).wrapping_add(56)).map(|x| x.wrapping_mul(9).wrapping_add(56)).map(|x| x.wrapping_mul(10).wrapping_add(56)).map(|x| x.wrapping_mul(11).wrapping_add(56)).map(|x| x.wrapping_mul(12).wrapping_add(56)).map(|x| x.wrapping_mul(13).wrapping_add(56)).map(|x| x.wrapping_mul(14).wrapping_add(56)).map(|x| x.wrapping_mul(15).wrapping_add(56)).map(|x| x.wrapping_mul(16).wrapping_add(56)).map(|x| x.wrapping_mul(17).wrapping_add(56)).map(|x| x.wrapping_mul(18).wrapping_add(56)).map(|x| x.wrapping_mul(19).wrapping_add(56)).map(|x| x.wrapping_mul(20).wrapping_add(56)).map(|x| x.wrapping_mul(21).wrapping_add(56)).map(|x| x.wrapping_mul(22).wrapping_add(56)).map(|x| x.wrapping_mul(23).wrapping_add(56)).map(|x| x.wrapping_mul(24).wrapping_add(56)).map(|x| x.wrapping_mul(25).wrapping_add(56)).map(|x| x.wrapping_mul(26).wrapping_add(56)).map(|x| x.wrapping_mul(27).wrapping_add(56)).map(|x| x.wrapping_mul(28).wrapping_add(56)).map(|x| x.wrapping_mul(29).wrapping_add(56)).map(|x| x.wrapping_mul(30).wrapping_add(56)).map(|x| x.wrapping_mul(31).wrapping_add(56)).map(|x| x.wrapping_mul(32).wrapping_add(56)).map(|x| x.wrapping_mul(33).wrapping_add(56)).map(|x| x.wrapping_mul(34).wrapping_add(56)).map(|x| x.wrapping_mul(35).wrapping_add(56)).map(|x| x.wrapping_mul(36).wrapping_add(56)).map(|x| x.wrapping_mul(37).wrapping_add(56)).map(|x| x.wrapping_mul(38).wrapping_add(56)).map(|x| x.wrapping_mul(39).wrapping_add(56)).map(|x| x.wrapping_mul(40).wrapping_add(56)).map(|x| x.wrapping_mul(41).wrapping_add(56)).map(|x| x.wrapping_mul(42).wrapping_add(56)).fold(0, u64::wrapping_add) } +pub fn busy_57() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(57)).map(|x| x.wrapping_mul(4).wrapping_add(57)).map(|x| x.wrapping_mul(5).wrapping_add(57)).map(|x| x.wrapping_mul(6).wrapping_add(57)).map(|x| x.wrapping_mul(7).wrapping_add(57)).map(|x| x.wrapping_mul(8).wrapping_add(57)).map(|x| x.wrapping_mul(9).wrapping_add(57)).map(|x| x.wrapping_mul(10).wrapping_add(57)).map(|x| x.wrapping_mul(11).wrapping_add(57)).map(|x| x.wrapping_mul(12).wrapping_add(57)).map(|x| x.wrapping_mul(13).wrapping_add(57)).map(|x| x.wrapping_mul(14).wrapping_add(57)).map(|x| x.wrapping_mul(15).wrapping_add(57)).map(|x| x.wrapping_mul(16).wrapping_add(57)).map(|x| x.wrapping_mul(17).wrapping_add(57)).map(|x| x.wrapping_mul(18).wrapping_add(57)).map(|x| x.wrapping_mul(19).wrapping_add(57)).map(|x| x.wrapping_mul(20).wrapping_add(57)).map(|x| x.wrapping_mul(21).wrapping_add(57)).map(|x| x.wrapping_mul(22).wrapping_add(57)).map(|x| x.wrapping_mul(23).wrapping_add(57)).map(|x| x.wrapping_mul(24).wrapping_add(57)).map(|x| x.wrapping_mul(25).wrapping_add(57)).map(|x| x.wrapping_mul(26).wrapping_add(57)).map(|x| x.wrapping_mul(27).wrapping_add(57)).map(|x| x.wrapping_mul(28).wrapping_add(57)).map(|x| x.wrapping_mul(29).wrapping_add(57)).map(|x| x.wrapping_mul(30).wrapping_add(57)).map(|x| x.wrapping_mul(31).wrapping_add(57)).map(|x| x.wrapping_mul(32).wrapping_add(57)).map(|x| x.wrapping_mul(33).wrapping_add(57)).map(|x| x.wrapping_mul(34).wrapping_add(57)).map(|x| x.wrapping_mul(35).wrapping_add(57)).map(|x| x.wrapping_mul(36).wrapping_add(57)).map(|x| x.wrapping_mul(37).wrapping_add(57)).map(|x| x.wrapping_mul(38).wrapping_add(57)).map(|x| x.wrapping_mul(39).wrapping_add(57)).map(|x| x.wrapping_mul(40).wrapping_add(57)).map(|x| x.wrapping_mul(41).wrapping_add(57)).map(|x| x.wrapping_mul(42).wrapping_add(57)).fold(0, u64::wrapping_add) } +pub fn busy_58() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(58)).map(|x| x.wrapping_mul(4).wrapping_add(58)).map(|x| x.wrapping_mul(5).wrapping_add(58)).map(|x| x.wrapping_mul(6).wrapping_add(58)).map(|x| x.wrapping_mul(7).wrapping_add(58)).map(|x| x.wrapping_mul(8).wrapping_add(58)).map(|x| x.wrapping_mul(9).wrapping_add(58)).map(|x| x.wrapping_mul(10).wrapping_add(58)).map(|x| x.wrapping_mul(11).wrapping_add(58)).map(|x| x.wrapping_mul(12).wrapping_add(58)).map(|x| x.wrapping_mul(13).wrapping_add(58)).map(|x| x.wrapping_mul(14).wrapping_add(58)).map(|x| x.wrapping_mul(15).wrapping_add(58)).map(|x| x.wrapping_mul(16).wrapping_add(58)).map(|x| x.wrapping_mul(17).wrapping_add(58)).map(|x| x.wrapping_mul(18).wrapping_add(58)).map(|x| x.wrapping_mul(19).wrapping_add(58)).map(|x| x.wrapping_mul(20).wrapping_add(58)).map(|x| x.wrapping_mul(21).wrapping_add(58)).map(|x| x.wrapping_mul(22).wrapping_add(58)).map(|x| x.wrapping_mul(23).wrapping_add(58)).map(|x| x.wrapping_mul(24).wrapping_add(58)).map(|x| x.wrapping_mul(25).wrapping_add(58)).map(|x| x.wrapping_mul(26).wrapping_add(58)).map(|x| x.wrapping_mul(27).wrapping_add(58)).map(|x| x.wrapping_mul(28).wrapping_add(58)).map(|x| x.wrapping_mul(29).wrapping_add(58)).map(|x| x.wrapping_mul(30).wrapping_add(58)).map(|x| x.wrapping_mul(31).wrapping_add(58)).map(|x| x.wrapping_mul(32).wrapping_add(58)).map(|x| x.wrapping_mul(33).wrapping_add(58)).map(|x| x.wrapping_mul(34).wrapping_add(58)).map(|x| x.wrapping_mul(35).wrapping_add(58)).map(|x| x.wrapping_mul(36).wrapping_add(58)).map(|x| x.wrapping_mul(37).wrapping_add(58)).map(|x| x.wrapping_mul(38).wrapping_add(58)).map(|x| x.wrapping_mul(39).wrapping_add(58)).map(|x| x.wrapping_mul(40).wrapping_add(58)).map(|x| x.wrapping_mul(41).wrapping_add(58)).map(|x| x.wrapping_mul(42).wrapping_add(58)).fold(0, u64::wrapping_add) } +pub fn busy_59() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(59)).map(|x| x.wrapping_mul(4).wrapping_add(59)).map(|x| x.wrapping_mul(5).wrapping_add(59)).map(|x| x.wrapping_mul(6).wrapping_add(59)).map(|x| x.wrapping_mul(7).wrapping_add(59)).map(|x| x.wrapping_mul(8).wrapping_add(59)).map(|x| x.wrapping_mul(9).wrapping_add(59)).map(|x| x.wrapping_mul(10).wrapping_add(59)).map(|x| x.wrapping_mul(11).wrapping_add(59)).map(|x| x.wrapping_mul(12).wrapping_add(59)).map(|x| x.wrapping_mul(13).wrapping_add(59)).map(|x| x.wrapping_mul(14).wrapping_add(59)).map(|x| x.wrapping_mul(15).wrapping_add(59)).map(|x| x.wrapping_mul(16).wrapping_add(59)).map(|x| x.wrapping_mul(17).wrapping_add(59)).map(|x| x.wrapping_mul(18).wrapping_add(59)).map(|x| x.wrapping_mul(19).wrapping_add(59)).map(|x| x.wrapping_mul(20).wrapping_add(59)).map(|x| x.wrapping_mul(21).wrapping_add(59)).map(|x| x.wrapping_mul(22).wrapping_add(59)).map(|x| x.wrapping_mul(23).wrapping_add(59)).map(|x| x.wrapping_mul(24).wrapping_add(59)).map(|x| x.wrapping_mul(25).wrapping_add(59)).map(|x| x.wrapping_mul(26).wrapping_add(59)).map(|x| x.wrapping_mul(27).wrapping_add(59)).map(|x| x.wrapping_mul(28).wrapping_add(59)).map(|x| x.wrapping_mul(29).wrapping_add(59)).map(|x| x.wrapping_mul(30).wrapping_add(59)).map(|x| x.wrapping_mul(31).wrapping_add(59)).map(|x| x.wrapping_mul(32).wrapping_add(59)).map(|x| x.wrapping_mul(33).wrapping_add(59)).map(|x| x.wrapping_mul(34).wrapping_add(59)).map(|x| x.wrapping_mul(35).wrapping_add(59)).map(|x| x.wrapping_mul(36).wrapping_add(59)).map(|x| x.wrapping_mul(37).wrapping_add(59)).map(|x| x.wrapping_mul(38).wrapping_add(59)).map(|x| x.wrapping_mul(39).wrapping_add(59)).map(|x| x.wrapping_mul(40).wrapping_add(59)).map(|x| x.wrapping_mul(41).wrapping_add(59)).map(|x| x.wrapping_mul(42).wrapping_add(59)).fold(0, u64::wrapping_add) } +pub fn busy_60() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(60)).map(|x| x.wrapping_mul(4).wrapping_add(60)).map(|x| x.wrapping_mul(5).wrapping_add(60)).map(|x| x.wrapping_mul(6).wrapping_add(60)).map(|x| x.wrapping_mul(7).wrapping_add(60)).map(|x| x.wrapping_mul(8).wrapping_add(60)).map(|x| x.wrapping_mul(9).wrapping_add(60)).map(|x| x.wrapping_mul(10).wrapping_add(60)).map(|x| x.wrapping_mul(11).wrapping_add(60)).map(|x| x.wrapping_mul(12).wrapping_add(60)).map(|x| x.wrapping_mul(13).wrapping_add(60)).map(|x| x.wrapping_mul(14).wrapping_add(60)).map(|x| x.wrapping_mul(15).wrapping_add(60)).map(|x| x.wrapping_mul(16).wrapping_add(60)).map(|x| x.wrapping_mul(17).wrapping_add(60)).map(|x| x.wrapping_mul(18).wrapping_add(60)).map(|x| x.wrapping_mul(19).wrapping_add(60)).map(|x| x.wrapping_mul(20).wrapping_add(60)).map(|x| x.wrapping_mul(21).wrapping_add(60)).map(|x| x.wrapping_mul(22).wrapping_add(60)).map(|x| x.wrapping_mul(23).wrapping_add(60)).map(|x| x.wrapping_mul(24).wrapping_add(60)).map(|x| x.wrapping_mul(25).wrapping_add(60)).map(|x| x.wrapping_mul(26).wrapping_add(60)).map(|x| x.wrapping_mul(27).wrapping_add(60)).map(|x| x.wrapping_mul(28).wrapping_add(60)).map(|x| x.wrapping_mul(29).wrapping_add(60)).map(|x| x.wrapping_mul(30).wrapping_add(60)).map(|x| x.wrapping_mul(31).wrapping_add(60)).map(|x| x.wrapping_mul(32).wrapping_add(60)).map(|x| x.wrapping_mul(33).wrapping_add(60)).map(|x| x.wrapping_mul(34).wrapping_add(60)).map(|x| x.wrapping_mul(35).wrapping_add(60)).map(|x| x.wrapping_mul(36).wrapping_add(60)).map(|x| x.wrapping_mul(37).wrapping_add(60)).map(|x| x.wrapping_mul(38).wrapping_add(60)).map(|x| x.wrapping_mul(39).wrapping_add(60)).map(|x| x.wrapping_mul(40).wrapping_add(60)).map(|x| x.wrapping_mul(41).wrapping_add(60)).map(|x| x.wrapping_mul(42).wrapping_add(60)).fold(0, u64::wrapping_add) } +pub fn busy_61() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(61)).map(|x| x.wrapping_mul(4).wrapping_add(61)).map(|x| x.wrapping_mul(5).wrapping_add(61)).map(|x| x.wrapping_mul(6).wrapping_add(61)).map(|x| x.wrapping_mul(7).wrapping_add(61)).map(|x| x.wrapping_mul(8).wrapping_add(61)).map(|x| x.wrapping_mul(9).wrapping_add(61)).map(|x| x.wrapping_mul(10).wrapping_add(61)).map(|x| x.wrapping_mul(11).wrapping_add(61)).map(|x| x.wrapping_mul(12).wrapping_add(61)).map(|x| x.wrapping_mul(13).wrapping_add(61)).map(|x| x.wrapping_mul(14).wrapping_add(61)).map(|x| x.wrapping_mul(15).wrapping_add(61)).map(|x| x.wrapping_mul(16).wrapping_add(61)).map(|x| x.wrapping_mul(17).wrapping_add(61)).map(|x| x.wrapping_mul(18).wrapping_add(61)).map(|x| x.wrapping_mul(19).wrapping_add(61)).map(|x| x.wrapping_mul(20).wrapping_add(61)).map(|x| x.wrapping_mul(21).wrapping_add(61)).map(|x| x.wrapping_mul(22).wrapping_add(61)).map(|x| x.wrapping_mul(23).wrapping_add(61)).map(|x| x.wrapping_mul(24).wrapping_add(61)).map(|x| x.wrapping_mul(25).wrapping_add(61)).map(|x| x.wrapping_mul(26).wrapping_add(61)).map(|x| x.wrapping_mul(27).wrapping_add(61)).map(|x| x.wrapping_mul(28).wrapping_add(61)).map(|x| x.wrapping_mul(29).wrapping_add(61)).map(|x| x.wrapping_mul(30).wrapping_add(61)).map(|x| x.wrapping_mul(31).wrapping_add(61)).map(|x| x.wrapping_mul(32).wrapping_add(61)).map(|x| x.wrapping_mul(33).wrapping_add(61)).map(|x| x.wrapping_mul(34).wrapping_add(61)).map(|x| x.wrapping_mul(35).wrapping_add(61)).map(|x| x.wrapping_mul(36).wrapping_add(61)).map(|x| x.wrapping_mul(37).wrapping_add(61)).map(|x| x.wrapping_mul(38).wrapping_add(61)).map(|x| x.wrapping_mul(39).wrapping_add(61)).map(|x| x.wrapping_mul(40).wrapping_add(61)).map(|x| x.wrapping_mul(41).wrapping_add(61)).map(|x| x.wrapping_mul(42).wrapping_add(61)).fold(0, u64::wrapping_add) } +pub fn busy_62() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(62)).map(|x| x.wrapping_mul(4).wrapping_add(62)).map(|x| x.wrapping_mul(5).wrapping_add(62)).map(|x| x.wrapping_mul(6).wrapping_add(62)).map(|x| x.wrapping_mul(7).wrapping_add(62)).map(|x| x.wrapping_mul(8).wrapping_add(62)).map(|x| x.wrapping_mul(9).wrapping_add(62)).map(|x| x.wrapping_mul(10).wrapping_add(62)).map(|x| x.wrapping_mul(11).wrapping_add(62)).map(|x| x.wrapping_mul(12).wrapping_add(62)).map(|x| x.wrapping_mul(13).wrapping_add(62)).map(|x| x.wrapping_mul(14).wrapping_add(62)).map(|x| x.wrapping_mul(15).wrapping_add(62)).map(|x| x.wrapping_mul(16).wrapping_add(62)).map(|x| x.wrapping_mul(17).wrapping_add(62)).map(|x| x.wrapping_mul(18).wrapping_add(62)).map(|x| x.wrapping_mul(19).wrapping_add(62)).map(|x| x.wrapping_mul(20).wrapping_add(62)).map(|x| x.wrapping_mul(21).wrapping_add(62)).map(|x| x.wrapping_mul(22).wrapping_add(62)).map(|x| x.wrapping_mul(23).wrapping_add(62)).map(|x| x.wrapping_mul(24).wrapping_add(62)).map(|x| x.wrapping_mul(25).wrapping_add(62)).map(|x| x.wrapping_mul(26).wrapping_add(62)).map(|x| x.wrapping_mul(27).wrapping_add(62)).map(|x| x.wrapping_mul(28).wrapping_add(62)).map(|x| x.wrapping_mul(29).wrapping_add(62)).map(|x| x.wrapping_mul(30).wrapping_add(62)).map(|x| x.wrapping_mul(31).wrapping_add(62)).map(|x| x.wrapping_mul(32).wrapping_add(62)).map(|x| x.wrapping_mul(33).wrapping_add(62)).map(|x| x.wrapping_mul(34).wrapping_add(62)).map(|x| x.wrapping_mul(35).wrapping_add(62)).map(|x| x.wrapping_mul(36).wrapping_add(62)).map(|x| x.wrapping_mul(37).wrapping_add(62)).map(|x| x.wrapping_mul(38).wrapping_add(62)).map(|x| x.wrapping_mul(39).wrapping_add(62)).map(|x| x.wrapping_mul(40).wrapping_add(62)).map(|x| x.wrapping_mul(41).wrapping_add(62)).map(|x| x.wrapping_mul(42).wrapping_add(62)).fold(0, u64::wrapping_add) } +pub fn busy_63() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(63)).map(|x| x.wrapping_mul(4).wrapping_add(63)).map(|x| x.wrapping_mul(5).wrapping_add(63)).map(|x| x.wrapping_mul(6).wrapping_add(63)).map(|x| x.wrapping_mul(7).wrapping_add(63)).map(|x| x.wrapping_mul(8).wrapping_add(63)).map(|x| x.wrapping_mul(9).wrapping_add(63)).map(|x| x.wrapping_mul(10).wrapping_add(63)).map(|x| x.wrapping_mul(11).wrapping_add(63)).map(|x| x.wrapping_mul(12).wrapping_add(63)).map(|x| x.wrapping_mul(13).wrapping_add(63)).map(|x| x.wrapping_mul(14).wrapping_add(63)).map(|x| x.wrapping_mul(15).wrapping_add(63)).map(|x| x.wrapping_mul(16).wrapping_add(63)).map(|x| x.wrapping_mul(17).wrapping_add(63)).map(|x| x.wrapping_mul(18).wrapping_add(63)).map(|x| x.wrapping_mul(19).wrapping_add(63)).map(|x| x.wrapping_mul(20).wrapping_add(63)).map(|x| x.wrapping_mul(21).wrapping_add(63)).map(|x| x.wrapping_mul(22).wrapping_add(63)).map(|x| x.wrapping_mul(23).wrapping_add(63)).map(|x| x.wrapping_mul(24).wrapping_add(63)).map(|x| x.wrapping_mul(25).wrapping_add(63)).map(|x| x.wrapping_mul(26).wrapping_add(63)).map(|x| x.wrapping_mul(27).wrapping_add(63)).map(|x| x.wrapping_mul(28).wrapping_add(63)).map(|x| x.wrapping_mul(29).wrapping_add(63)).map(|x| x.wrapping_mul(30).wrapping_add(63)).map(|x| x.wrapping_mul(31).wrapping_add(63)).map(|x| x.wrapping_mul(32).wrapping_add(63)).map(|x| x.wrapping_mul(33).wrapping_add(63)).map(|x| x.wrapping_mul(34).wrapping_add(63)).map(|x| x.wrapping_mul(35).wrapping_add(63)).map(|x| x.wrapping_mul(36).wrapping_add(63)).map(|x| x.wrapping_mul(37).wrapping_add(63)).map(|x| x.wrapping_mul(38).wrapping_add(63)).map(|x| x.wrapping_mul(39).wrapping_add(63)).map(|x| x.wrapping_mul(40).wrapping_add(63)).map(|x| x.wrapping_mul(41).wrapping_add(63)).map(|x| x.wrapping_mul(42).wrapping_add(63)).fold(0, u64::wrapping_add) } +pub fn busy_64() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(64)).map(|x| x.wrapping_mul(4).wrapping_add(64)).map(|x| x.wrapping_mul(5).wrapping_add(64)).map(|x| x.wrapping_mul(6).wrapping_add(64)).map(|x| x.wrapping_mul(7).wrapping_add(64)).map(|x| x.wrapping_mul(8).wrapping_add(64)).map(|x| x.wrapping_mul(9).wrapping_add(64)).map(|x| x.wrapping_mul(10).wrapping_add(64)).map(|x| x.wrapping_mul(11).wrapping_add(64)).map(|x| x.wrapping_mul(12).wrapping_add(64)).map(|x| x.wrapping_mul(13).wrapping_add(64)).map(|x| x.wrapping_mul(14).wrapping_add(64)).map(|x| x.wrapping_mul(15).wrapping_add(64)).map(|x| x.wrapping_mul(16).wrapping_add(64)).map(|x| x.wrapping_mul(17).wrapping_add(64)).map(|x| x.wrapping_mul(18).wrapping_add(64)).map(|x| x.wrapping_mul(19).wrapping_add(64)).map(|x| x.wrapping_mul(20).wrapping_add(64)).map(|x| x.wrapping_mul(21).wrapping_add(64)).map(|x| x.wrapping_mul(22).wrapping_add(64)).map(|x| x.wrapping_mul(23).wrapping_add(64)).map(|x| x.wrapping_mul(24).wrapping_add(64)).map(|x| x.wrapping_mul(25).wrapping_add(64)).map(|x| x.wrapping_mul(26).wrapping_add(64)).map(|x| x.wrapping_mul(27).wrapping_add(64)).map(|x| x.wrapping_mul(28).wrapping_add(64)).map(|x| x.wrapping_mul(29).wrapping_add(64)).map(|x| x.wrapping_mul(30).wrapping_add(64)).map(|x| x.wrapping_mul(31).wrapping_add(64)).map(|x| x.wrapping_mul(32).wrapping_add(64)).map(|x| x.wrapping_mul(33).wrapping_add(64)).map(|x| x.wrapping_mul(34).wrapping_add(64)).map(|x| x.wrapping_mul(35).wrapping_add(64)).map(|x| x.wrapping_mul(36).wrapping_add(64)).map(|x| x.wrapping_mul(37).wrapping_add(64)).map(|x| x.wrapping_mul(38).wrapping_add(64)).map(|x| x.wrapping_mul(39).wrapping_add(64)).map(|x| x.wrapping_mul(40).wrapping_add(64)).map(|x| x.wrapping_mul(41).wrapping_add(64)).map(|x| x.wrapping_mul(42).wrapping_add(64)).fold(0, u64::wrapping_add) } +pub fn busy_65() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(65)).map(|x| x.wrapping_mul(4).wrapping_add(65)).map(|x| x.wrapping_mul(5).wrapping_add(65)).map(|x| x.wrapping_mul(6).wrapping_add(65)).map(|x| x.wrapping_mul(7).wrapping_add(65)).map(|x| x.wrapping_mul(8).wrapping_add(65)).map(|x| x.wrapping_mul(9).wrapping_add(65)).map(|x| x.wrapping_mul(10).wrapping_add(65)).map(|x| x.wrapping_mul(11).wrapping_add(65)).map(|x| x.wrapping_mul(12).wrapping_add(65)).map(|x| x.wrapping_mul(13).wrapping_add(65)).map(|x| x.wrapping_mul(14).wrapping_add(65)).map(|x| x.wrapping_mul(15).wrapping_add(65)).map(|x| x.wrapping_mul(16).wrapping_add(65)).map(|x| x.wrapping_mul(17).wrapping_add(65)).map(|x| x.wrapping_mul(18).wrapping_add(65)).map(|x| x.wrapping_mul(19).wrapping_add(65)).map(|x| x.wrapping_mul(20).wrapping_add(65)).map(|x| x.wrapping_mul(21).wrapping_add(65)).map(|x| x.wrapping_mul(22).wrapping_add(65)).map(|x| x.wrapping_mul(23).wrapping_add(65)).map(|x| x.wrapping_mul(24).wrapping_add(65)).map(|x| x.wrapping_mul(25).wrapping_add(65)).map(|x| x.wrapping_mul(26).wrapping_add(65)).map(|x| x.wrapping_mul(27).wrapping_add(65)).map(|x| x.wrapping_mul(28).wrapping_add(65)).map(|x| x.wrapping_mul(29).wrapping_add(65)).map(|x| x.wrapping_mul(30).wrapping_add(65)).map(|x| x.wrapping_mul(31).wrapping_add(65)).map(|x| x.wrapping_mul(32).wrapping_add(65)).map(|x| x.wrapping_mul(33).wrapping_add(65)).map(|x| x.wrapping_mul(34).wrapping_add(65)).map(|x| x.wrapping_mul(35).wrapping_add(65)).map(|x| x.wrapping_mul(36).wrapping_add(65)).map(|x| x.wrapping_mul(37).wrapping_add(65)).map(|x| x.wrapping_mul(38).wrapping_add(65)).map(|x| x.wrapping_mul(39).wrapping_add(65)).map(|x| x.wrapping_mul(40).wrapping_add(65)).map(|x| x.wrapping_mul(41).wrapping_add(65)).map(|x| x.wrapping_mul(42).wrapping_add(65)).fold(0, u64::wrapping_add) } +pub fn busy_66() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(66)).map(|x| x.wrapping_mul(4).wrapping_add(66)).map(|x| x.wrapping_mul(5).wrapping_add(66)).map(|x| x.wrapping_mul(6).wrapping_add(66)).map(|x| x.wrapping_mul(7).wrapping_add(66)).map(|x| x.wrapping_mul(8).wrapping_add(66)).map(|x| x.wrapping_mul(9).wrapping_add(66)).map(|x| x.wrapping_mul(10).wrapping_add(66)).map(|x| x.wrapping_mul(11).wrapping_add(66)).map(|x| x.wrapping_mul(12).wrapping_add(66)).map(|x| x.wrapping_mul(13).wrapping_add(66)).map(|x| x.wrapping_mul(14).wrapping_add(66)).map(|x| x.wrapping_mul(15).wrapping_add(66)).map(|x| x.wrapping_mul(16).wrapping_add(66)).map(|x| x.wrapping_mul(17).wrapping_add(66)).map(|x| x.wrapping_mul(18).wrapping_add(66)).map(|x| x.wrapping_mul(19).wrapping_add(66)).map(|x| x.wrapping_mul(20).wrapping_add(66)).map(|x| x.wrapping_mul(21).wrapping_add(66)).map(|x| x.wrapping_mul(22).wrapping_add(66)).map(|x| x.wrapping_mul(23).wrapping_add(66)).map(|x| x.wrapping_mul(24).wrapping_add(66)).map(|x| x.wrapping_mul(25).wrapping_add(66)).map(|x| x.wrapping_mul(26).wrapping_add(66)).map(|x| x.wrapping_mul(27).wrapping_add(66)).map(|x| x.wrapping_mul(28).wrapping_add(66)).map(|x| x.wrapping_mul(29).wrapping_add(66)).map(|x| x.wrapping_mul(30).wrapping_add(66)).map(|x| x.wrapping_mul(31).wrapping_add(66)).map(|x| x.wrapping_mul(32).wrapping_add(66)).map(|x| x.wrapping_mul(33).wrapping_add(66)).map(|x| x.wrapping_mul(34).wrapping_add(66)).map(|x| x.wrapping_mul(35).wrapping_add(66)).map(|x| x.wrapping_mul(36).wrapping_add(66)).map(|x| x.wrapping_mul(37).wrapping_add(66)).map(|x| x.wrapping_mul(38).wrapping_add(66)).map(|x| x.wrapping_mul(39).wrapping_add(66)).map(|x| x.wrapping_mul(40).wrapping_add(66)).map(|x| x.wrapping_mul(41).wrapping_add(66)).map(|x| x.wrapping_mul(42).wrapping_add(66)).fold(0, u64::wrapping_add) } +pub fn busy_67() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(67)).map(|x| x.wrapping_mul(4).wrapping_add(67)).map(|x| x.wrapping_mul(5).wrapping_add(67)).map(|x| x.wrapping_mul(6).wrapping_add(67)).map(|x| x.wrapping_mul(7).wrapping_add(67)).map(|x| x.wrapping_mul(8).wrapping_add(67)).map(|x| x.wrapping_mul(9).wrapping_add(67)).map(|x| x.wrapping_mul(10).wrapping_add(67)).map(|x| x.wrapping_mul(11).wrapping_add(67)).map(|x| x.wrapping_mul(12).wrapping_add(67)).map(|x| x.wrapping_mul(13).wrapping_add(67)).map(|x| x.wrapping_mul(14).wrapping_add(67)).map(|x| x.wrapping_mul(15).wrapping_add(67)).map(|x| x.wrapping_mul(16).wrapping_add(67)).map(|x| x.wrapping_mul(17).wrapping_add(67)).map(|x| x.wrapping_mul(18).wrapping_add(67)).map(|x| x.wrapping_mul(19).wrapping_add(67)).map(|x| x.wrapping_mul(20).wrapping_add(67)).map(|x| x.wrapping_mul(21).wrapping_add(67)).map(|x| x.wrapping_mul(22).wrapping_add(67)).map(|x| x.wrapping_mul(23).wrapping_add(67)).map(|x| x.wrapping_mul(24).wrapping_add(67)).map(|x| x.wrapping_mul(25).wrapping_add(67)).map(|x| x.wrapping_mul(26).wrapping_add(67)).map(|x| x.wrapping_mul(27).wrapping_add(67)).map(|x| x.wrapping_mul(28).wrapping_add(67)).map(|x| x.wrapping_mul(29).wrapping_add(67)).map(|x| x.wrapping_mul(30).wrapping_add(67)).map(|x| x.wrapping_mul(31).wrapping_add(67)).map(|x| x.wrapping_mul(32).wrapping_add(67)).map(|x| x.wrapping_mul(33).wrapping_add(67)).map(|x| x.wrapping_mul(34).wrapping_add(67)).map(|x| x.wrapping_mul(35).wrapping_add(67)).map(|x| x.wrapping_mul(36).wrapping_add(67)).map(|x| x.wrapping_mul(37).wrapping_add(67)).map(|x| x.wrapping_mul(38).wrapping_add(67)).map(|x| x.wrapping_mul(39).wrapping_add(67)).map(|x| x.wrapping_mul(40).wrapping_add(67)).map(|x| x.wrapping_mul(41).wrapping_add(67)).map(|x| x.wrapping_mul(42).wrapping_add(67)).fold(0, u64::wrapping_add) } +pub fn busy_68() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(68)).map(|x| x.wrapping_mul(4).wrapping_add(68)).map(|x| x.wrapping_mul(5).wrapping_add(68)).map(|x| x.wrapping_mul(6).wrapping_add(68)).map(|x| x.wrapping_mul(7).wrapping_add(68)).map(|x| x.wrapping_mul(8).wrapping_add(68)).map(|x| x.wrapping_mul(9).wrapping_add(68)).map(|x| x.wrapping_mul(10).wrapping_add(68)).map(|x| x.wrapping_mul(11).wrapping_add(68)).map(|x| x.wrapping_mul(12).wrapping_add(68)).map(|x| x.wrapping_mul(13).wrapping_add(68)).map(|x| x.wrapping_mul(14).wrapping_add(68)).map(|x| x.wrapping_mul(15).wrapping_add(68)).map(|x| x.wrapping_mul(16).wrapping_add(68)).map(|x| x.wrapping_mul(17).wrapping_add(68)).map(|x| x.wrapping_mul(18).wrapping_add(68)).map(|x| x.wrapping_mul(19).wrapping_add(68)).map(|x| x.wrapping_mul(20).wrapping_add(68)).map(|x| x.wrapping_mul(21).wrapping_add(68)).map(|x| x.wrapping_mul(22).wrapping_add(68)).map(|x| x.wrapping_mul(23).wrapping_add(68)).map(|x| x.wrapping_mul(24).wrapping_add(68)).map(|x| x.wrapping_mul(25).wrapping_add(68)).map(|x| x.wrapping_mul(26).wrapping_add(68)).map(|x| x.wrapping_mul(27).wrapping_add(68)).map(|x| x.wrapping_mul(28).wrapping_add(68)).map(|x| x.wrapping_mul(29).wrapping_add(68)).map(|x| x.wrapping_mul(30).wrapping_add(68)).map(|x| x.wrapping_mul(31).wrapping_add(68)).map(|x| x.wrapping_mul(32).wrapping_add(68)).map(|x| x.wrapping_mul(33).wrapping_add(68)).map(|x| x.wrapping_mul(34).wrapping_add(68)).map(|x| x.wrapping_mul(35).wrapping_add(68)).map(|x| x.wrapping_mul(36).wrapping_add(68)).map(|x| x.wrapping_mul(37).wrapping_add(68)).map(|x| x.wrapping_mul(38).wrapping_add(68)).map(|x| x.wrapping_mul(39).wrapping_add(68)).map(|x| x.wrapping_mul(40).wrapping_add(68)).map(|x| x.wrapping_mul(41).wrapping_add(68)).map(|x| x.wrapping_mul(42).wrapping_add(68)).fold(0, u64::wrapping_add) } +pub fn busy_69() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(69)).map(|x| x.wrapping_mul(4).wrapping_add(69)).map(|x| x.wrapping_mul(5).wrapping_add(69)).map(|x| x.wrapping_mul(6).wrapping_add(69)).map(|x| x.wrapping_mul(7).wrapping_add(69)).map(|x| x.wrapping_mul(8).wrapping_add(69)).map(|x| x.wrapping_mul(9).wrapping_add(69)).map(|x| x.wrapping_mul(10).wrapping_add(69)).map(|x| x.wrapping_mul(11).wrapping_add(69)).map(|x| x.wrapping_mul(12).wrapping_add(69)).map(|x| x.wrapping_mul(13).wrapping_add(69)).map(|x| x.wrapping_mul(14).wrapping_add(69)).map(|x| x.wrapping_mul(15).wrapping_add(69)).map(|x| x.wrapping_mul(16).wrapping_add(69)).map(|x| x.wrapping_mul(17).wrapping_add(69)).map(|x| x.wrapping_mul(18).wrapping_add(69)).map(|x| x.wrapping_mul(19).wrapping_add(69)).map(|x| x.wrapping_mul(20).wrapping_add(69)).map(|x| x.wrapping_mul(21).wrapping_add(69)).map(|x| x.wrapping_mul(22).wrapping_add(69)).map(|x| x.wrapping_mul(23).wrapping_add(69)).map(|x| x.wrapping_mul(24).wrapping_add(69)).map(|x| x.wrapping_mul(25).wrapping_add(69)).map(|x| x.wrapping_mul(26).wrapping_add(69)).map(|x| x.wrapping_mul(27).wrapping_add(69)).map(|x| x.wrapping_mul(28).wrapping_add(69)).map(|x| x.wrapping_mul(29).wrapping_add(69)).map(|x| x.wrapping_mul(30).wrapping_add(69)).map(|x| x.wrapping_mul(31).wrapping_add(69)).map(|x| x.wrapping_mul(32).wrapping_add(69)).map(|x| x.wrapping_mul(33).wrapping_add(69)).map(|x| x.wrapping_mul(34).wrapping_add(69)).map(|x| x.wrapping_mul(35).wrapping_add(69)).map(|x| x.wrapping_mul(36).wrapping_add(69)).map(|x| x.wrapping_mul(37).wrapping_add(69)).map(|x| x.wrapping_mul(38).wrapping_add(69)).map(|x| x.wrapping_mul(39).wrapping_add(69)).map(|x| x.wrapping_mul(40).wrapping_add(69)).map(|x| x.wrapping_mul(41).wrapping_add(69)).map(|x| x.wrapping_mul(42).wrapping_add(69)).fold(0, u64::wrapping_add) } +pub fn busy_70() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(70)).map(|x| x.wrapping_mul(4).wrapping_add(70)).map(|x| x.wrapping_mul(5).wrapping_add(70)).map(|x| x.wrapping_mul(6).wrapping_add(70)).map(|x| x.wrapping_mul(7).wrapping_add(70)).map(|x| x.wrapping_mul(8).wrapping_add(70)).map(|x| x.wrapping_mul(9).wrapping_add(70)).map(|x| x.wrapping_mul(10).wrapping_add(70)).map(|x| x.wrapping_mul(11).wrapping_add(70)).map(|x| x.wrapping_mul(12).wrapping_add(70)).map(|x| x.wrapping_mul(13).wrapping_add(70)).map(|x| x.wrapping_mul(14).wrapping_add(70)).map(|x| x.wrapping_mul(15).wrapping_add(70)).map(|x| x.wrapping_mul(16).wrapping_add(70)).map(|x| x.wrapping_mul(17).wrapping_add(70)).map(|x| x.wrapping_mul(18).wrapping_add(70)).map(|x| x.wrapping_mul(19).wrapping_add(70)).map(|x| x.wrapping_mul(20).wrapping_add(70)).map(|x| x.wrapping_mul(21).wrapping_add(70)).map(|x| x.wrapping_mul(22).wrapping_add(70)).map(|x| x.wrapping_mul(23).wrapping_add(70)).map(|x| x.wrapping_mul(24).wrapping_add(70)).map(|x| x.wrapping_mul(25).wrapping_add(70)).map(|x| x.wrapping_mul(26).wrapping_add(70)).map(|x| x.wrapping_mul(27).wrapping_add(70)).map(|x| x.wrapping_mul(28).wrapping_add(70)).map(|x| x.wrapping_mul(29).wrapping_add(70)).map(|x| x.wrapping_mul(30).wrapping_add(70)).map(|x| x.wrapping_mul(31).wrapping_add(70)).map(|x| x.wrapping_mul(32).wrapping_add(70)).map(|x| x.wrapping_mul(33).wrapping_add(70)).map(|x| x.wrapping_mul(34).wrapping_add(70)).map(|x| x.wrapping_mul(35).wrapping_add(70)).map(|x| x.wrapping_mul(36).wrapping_add(70)).map(|x| x.wrapping_mul(37).wrapping_add(70)).map(|x| x.wrapping_mul(38).wrapping_add(70)).map(|x| x.wrapping_mul(39).wrapping_add(70)).map(|x| x.wrapping_mul(40).wrapping_add(70)).map(|x| x.wrapping_mul(41).wrapping_add(70)).map(|x| x.wrapping_mul(42).wrapping_add(70)).fold(0, u64::wrapping_add) } +pub fn busy_71() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(71)).map(|x| x.wrapping_mul(4).wrapping_add(71)).map(|x| x.wrapping_mul(5).wrapping_add(71)).map(|x| x.wrapping_mul(6).wrapping_add(71)).map(|x| x.wrapping_mul(7).wrapping_add(71)).map(|x| x.wrapping_mul(8).wrapping_add(71)).map(|x| x.wrapping_mul(9).wrapping_add(71)).map(|x| x.wrapping_mul(10).wrapping_add(71)).map(|x| x.wrapping_mul(11).wrapping_add(71)).map(|x| x.wrapping_mul(12).wrapping_add(71)).map(|x| x.wrapping_mul(13).wrapping_add(71)).map(|x| x.wrapping_mul(14).wrapping_add(71)).map(|x| x.wrapping_mul(15).wrapping_add(71)).map(|x| x.wrapping_mul(16).wrapping_add(71)).map(|x| x.wrapping_mul(17).wrapping_add(71)).map(|x| x.wrapping_mul(18).wrapping_add(71)).map(|x| x.wrapping_mul(19).wrapping_add(71)).map(|x| x.wrapping_mul(20).wrapping_add(71)).map(|x| x.wrapping_mul(21).wrapping_add(71)).map(|x| x.wrapping_mul(22).wrapping_add(71)).map(|x| x.wrapping_mul(23).wrapping_add(71)).map(|x| x.wrapping_mul(24).wrapping_add(71)).map(|x| x.wrapping_mul(25).wrapping_add(71)).map(|x| x.wrapping_mul(26).wrapping_add(71)).map(|x| x.wrapping_mul(27).wrapping_add(71)).map(|x| x.wrapping_mul(28).wrapping_add(71)).map(|x| x.wrapping_mul(29).wrapping_add(71)).map(|x| x.wrapping_mul(30).wrapping_add(71)).map(|x| x.wrapping_mul(31).wrapping_add(71)).map(|x| x.wrapping_mul(32).wrapping_add(71)).map(|x| x.wrapping_mul(33).wrapping_add(71)).map(|x| x.wrapping_mul(34).wrapping_add(71)).map(|x| x.wrapping_mul(35).wrapping_add(71)).map(|x| x.wrapping_mul(36).wrapping_add(71)).map(|x| x.wrapping_mul(37).wrapping_add(71)).map(|x| x.wrapping_mul(38).wrapping_add(71)).map(|x| x.wrapping_mul(39).wrapping_add(71)).map(|x| x.wrapping_mul(40).wrapping_add(71)).map(|x| x.wrapping_mul(41).wrapping_add(71)).map(|x| x.wrapping_mul(42).wrapping_add(71)).fold(0, u64::wrapping_add) } +pub fn busy_72() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(72)).map(|x| x.wrapping_mul(4).wrapping_add(72)).map(|x| x.wrapping_mul(5).wrapping_add(72)).map(|x| x.wrapping_mul(6).wrapping_add(72)).map(|x| x.wrapping_mul(7).wrapping_add(72)).map(|x| x.wrapping_mul(8).wrapping_add(72)).map(|x| x.wrapping_mul(9).wrapping_add(72)).map(|x| x.wrapping_mul(10).wrapping_add(72)).map(|x| x.wrapping_mul(11).wrapping_add(72)).map(|x| x.wrapping_mul(12).wrapping_add(72)).map(|x| x.wrapping_mul(13).wrapping_add(72)).map(|x| x.wrapping_mul(14).wrapping_add(72)).map(|x| x.wrapping_mul(15).wrapping_add(72)).map(|x| x.wrapping_mul(16).wrapping_add(72)).map(|x| x.wrapping_mul(17).wrapping_add(72)).map(|x| x.wrapping_mul(18).wrapping_add(72)).map(|x| x.wrapping_mul(19).wrapping_add(72)).map(|x| x.wrapping_mul(20).wrapping_add(72)).map(|x| x.wrapping_mul(21).wrapping_add(72)).map(|x| x.wrapping_mul(22).wrapping_add(72)).map(|x| x.wrapping_mul(23).wrapping_add(72)).map(|x| x.wrapping_mul(24).wrapping_add(72)).map(|x| x.wrapping_mul(25).wrapping_add(72)).map(|x| x.wrapping_mul(26).wrapping_add(72)).map(|x| x.wrapping_mul(27).wrapping_add(72)).map(|x| x.wrapping_mul(28).wrapping_add(72)).map(|x| x.wrapping_mul(29).wrapping_add(72)).map(|x| x.wrapping_mul(30).wrapping_add(72)).map(|x| x.wrapping_mul(31).wrapping_add(72)).map(|x| x.wrapping_mul(32).wrapping_add(72)).map(|x| x.wrapping_mul(33).wrapping_add(72)).map(|x| x.wrapping_mul(34).wrapping_add(72)).map(|x| x.wrapping_mul(35).wrapping_add(72)).map(|x| x.wrapping_mul(36).wrapping_add(72)).map(|x| x.wrapping_mul(37).wrapping_add(72)).map(|x| x.wrapping_mul(38).wrapping_add(72)).map(|x| x.wrapping_mul(39).wrapping_add(72)).map(|x| x.wrapping_mul(40).wrapping_add(72)).map(|x| x.wrapping_mul(41).wrapping_add(72)).map(|x| x.wrapping_mul(42).wrapping_add(72)).fold(0, u64::wrapping_add) } +pub fn busy_73() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(73)).map(|x| x.wrapping_mul(4).wrapping_add(73)).map(|x| x.wrapping_mul(5).wrapping_add(73)).map(|x| x.wrapping_mul(6).wrapping_add(73)).map(|x| x.wrapping_mul(7).wrapping_add(73)).map(|x| x.wrapping_mul(8).wrapping_add(73)).map(|x| x.wrapping_mul(9).wrapping_add(73)).map(|x| x.wrapping_mul(10).wrapping_add(73)).map(|x| x.wrapping_mul(11).wrapping_add(73)).map(|x| x.wrapping_mul(12).wrapping_add(73)).map(|x| x.wrapping_mul(13).wrapping_add(73)).map(|x| x.wrapping_mul(14).wrapping_add(73)).map(|x| x.wrapping_mul(15).wrapping_add(73)).map(|x| x.wrapping_mul(16).wrapping_add(73)).map(|x| x.wrapping_mul(17).wrapping_add(73)).map(|x| x.wrapping_mul(18).wrapping_add(73)).map(|x| x.wrapping_mul(19).wrapping_add(73)).map(|x| x.wrapping_mul(20).wrapping_add(73)).map(|x| x.wrapping_mul(21).wrapping_add(73)).map(|x| x.wrapping_mul(22).wrapping_add(73)).map(|x| x.wrapping_mul(23).wrapping_add(73)).map(|x| x.wrapping_mul(24).wrapping_add(73)).map(|x| x.wrapping_mul(25).wrapping_add(73)).map(|x| x.wrapping_mul(26).wrapping_add(73)).map(|x| x.wrapping_mul(27).wrapping_add(73)).map(|x| x.wrapping_mul(28).wrapping_add(73)).map(|x| x.wrapping_mul(29).wrapping_add(73)).map(|x| x.wrapping_mul(30).wrapping_add(73)).map(|x| x.wrapping_mul(31).wrapping_add(73)).map(|x| x.wrapping_mul(32).wrapping_add(73)).map(|x| x.wrapping_mul(33).wrapping_add(73)).map(|x| x.wrapping_mul(34).wrapping_add(73)).map(|x| x.wrapping_mul(35).wrapping_add(73)).map(|x| x.wrapping_mul(36).wrapping_add(73)).map(|x| x.wrapping_mul(37).wrapping_add(73)).map(|x| x.wrapping_mul(38).wrapping_add(73)).map(|x| x.wrapping_mul(39).wrapping_add(73)).map(|x| x.wrapping_mul(40).wrapping_add(73)).map(|x| x.wrapping_mul(41).wrapping_add(73)).map(|x| x.wrapping_mul(42).wrapping_add(73)).fold(0, u64::wrapping_add) } +pub fn busy_74() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(74)).map(|x| x.wrapping_mul(4).wrapping_add(74)).map(|x| x.wrapping_mul(5).wrapping_add(74)).map(|x| x.wrapping_mul(6).wrapping_add(74)).map(|x| x.wrapping_mul(7).wrapping_add(74)).map(|x| x.wrapping_mul(8).wrapping_add(74)).map(|x| x.wrapping_mul(9).wrapping_add(74)).map(|x| x.wrapping_mul(10).wrapping_add(74)).map(|x| x.wrapping_mul(11).wrapping_add(74)).map(|x| x.wrapping_mul(12).wrapping_add(74)).map(|x| x.wrapping_mul(13).wrapping_add(74)).map(|x| x.wrapping_mul(14).wrapping_add(74)).map(|x| x.wrapping_mul(15).wrapping_add(74)).map(|x| x.wrapping_mul(16).wrapping_add(74)).map(|x| x.wrapping_mul(17).wrapping_add(74)).map(|x| x.wrapping_mul(18).wrapping_add(74)).map(|x| x.wrapping_mul(19).wrapping_add(74)).map(|x| x.wrapping_mul(20).wrapping_add(74)).map(|x| x.wrapping_mul(21).wrapping_add(74)).map(|x| x.wrapping_mul(22).wrapping_add(74)).map(|x| x.wrapping_mul(23).wrapping_add(74)).map(|x| x.wrapping_mul(24).wrapping_add(74)).map(|x| x.wrapping_mul(25).wrapping_add(74)).map(|x| x.wrapping_mul(26).wrapping_add(74)).map(|x| x.wrapping_mul(27).wrapping_add(74)).map(|x| x.wrapping_mul(28).wrapping_add(74)).map(|x| x.wrapping_mul(29).wrapping_add(74)).map(|x| x.wrapping_mul(30).wrapping_add(74)).map(|x| x.wrapping_mul(31).wrapping_add(74)).map(|x| x.wrapping_mul(32).wrapping_add(74)).map(|x| x.wrapping_mul(33).wrapping_add(74)).map(|x| x.wrapping_mul(34).wrapping_add(74)).map(|x| x.wrapping_mul(35).wrapping_add(74)).map(|x| x.wrapping_mul(36).wrapping_add(74)).map(|x| x.wrapping_mul(37).wrapping_add(74)).map(|x| x.wrapping_mul(38).wrapping_add(74)).map(|x| x.wrapping_mul(39).wrapping_add(74)).map(|x| x.wrapping_mul(40).wrapping_add(74)).map(|x| x.wrapping_mul(41).wrapping_add(74)).map(|x| x.wrapping_mul(42).wrapping_add(74)).fold(0, u64::wrapping_add) } +pub fn busy_75() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(75)).map(|x| x.wrapping_mul(4).wrapping_add(75)).map(|x| x.wrapping_mul(5).wrapping_add(75)).map(|x| x.wrapping_mul(6).wrapping_add(75)).map(|x| x.wrapping_mul(7).wrapping_add(75)).map(|x| x.wrapping_mul(8).wrapping_add(75)).map(|x| x.wrapping_mul(9).wrapping_add(75)).map(|x| x.wrapping_mul(10).wrapping_add(75)).map(|x| x.wrapping_mul(11).wrapping_add(75)).map(|x| x.wrapping_mul(12).wrapping_add(75)).map(|x| x.wrapping_mul(13).wrapping_add(75)).map(|x| x.wrapping_mul(14).wrapping_add(75)).map(|x| x.wrapping_mul(15).wrapping_add(75)).map(|x| x.wrapping_mul(16).wrapping_add(75)).map(|x| x.wrapping_mul(17).wrapping_add(75)).map(|x| x.wrapping_mul(18).wrapping_add(75)).map(|x| x.wrapping_mul(19).wrapping_add(75)).map(|x| x.wrapping_mul(20).wrapping_add(75)).map(|x| x.wrapping_mul(21).wrapping_add(75)).map(|x| x.wrapping_mul(22).wrapping_add(75)).map(|x| x.wrapping_mul(23).wrapping_add(75)).map(|x| x.wrapping_mul(24).wrapping_add(75)).map(|x| x.wrapping_mul(25).wrapping_add(75)).map(|x| x.wrapping_mul(26).wrapping_add(75)).map(|x| x.wrapping_mul(27).wrapping_add(75)).map(|x| x.wrapping_mul(28).wrapping_add(75)).map(|x| x.wrapping_mul(29).wrapping_add(75)).map(|x| x.wrapping_mul(30).wrapping_add(75)).map(|x| x.wrapping_mul(31).wrapping_add(75)).map(|x| x.wrapping_mul(32).wrapping_add(75)).map(|x| x.wrapping_mul(33).wrapping_add(75)).map(|x| x.wrapping_mul(34).wrapping_add(75)).map(|x| x.wrapping_mul(35).wrapping_add(75)).map(|x| x.wrapping_mul(36).wrapping_add(75)).map(|x| x.wrapping_mul(37).wrapping_add(75)).map(|x| x.wrapping_mul(38).wrapping_add(75)).map(|x| x.wrapping_mul(39).wrapping_add(75)).map(|x| x.wrapping_mul(40).wrapping_add(75)).map(|x| x.wrapping_mul(41).wrapping_add(75)).map(|x| x.wrapping_mul(42).wrapping_add(75)).fold(0, u64::wrapping_add) } +pub fn busy_76() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(76)).map(|x| x.wrapping_mul(4).wrapping_add(76)).map(|x| x.wrapping_mul(5).wrapping_add(76)).map(|x| x.wrapping_mul(6).wrapping_add(76)).map(|x| x.wrapping_mul(7).wrapping_add(76)).map(|x| x.wrapping_mul(8).wrapping_add(76)).map(|x| x.wrapping_mul(9).wrapping_add(76)).map(|x| x.wrapping_mul(10).wrapping_add(76)).map(|x| x.wrapping_mul(11).wrapping_add(76)).map(|x| x.wrapping_mul(12).wrapping_add(76)).map(|x| x.wrapping_mul(13).wrapping_add(76)).map(|x| x.wrapping_mul(14).wrapping_add(76)).map(|x| x.wrapping_mul(15).wrapping_add(76)).map(|x| x.wrapping_mul(16).wrapping_add(76)).map(|x| x.wrapping_mul(17).wrapping_add(76)).map(|x| x.wrapping_mul(18).wrapping_add(76)).map(|x| x.wrapping_mul(19).wrapping_add(76)).map(|x| x.wrapping_mul(20).wrapping_add(76)).map(|x| x.wrapping_mul(21).wrapping_add(76)).map(|x| x.wrapping_mul(22).wrapping_add(76)).map(|x| x.wrapping_mul(23).wrapping_add(76)).map(|x| x.wrapping_mul(24).wrapping_add(76)).map(|x| x.wrapping_mul(25).wrapping_add(76)).map(|x| x.wrapping_mul(26).wrapping_add(76)).map(|x| x.wrapping_mul(27).wrapping_add(76)).map(|x| x.wrapping_mul(28).wrapping_add(76)).map(|x| x.wrapping_mul(29).wrapping_add(76)).map(|x| x.wrapping_mul(30).wrapping_add(76)).map(|x| x.wrapping_mul(31).wrapping_add(76)).map(|x| x.wrapping_mul(32).wrapping_add(76)).map(|x| x.wrapping_mul(33).wrapping_add(76)).map(|x| x.wrapping_mul(34).wrapping_add(76)).map(|x| x.wrapping_mul(35).wrapping_add(76)).map(|x| x.wrapping_mul(36).wrapping_add(76)).map(|x| x.wrapping_mul(37).wrapping_add(76)).map(|x| x.wrapping_mul(38).wrapping_add(76)).map(|x| x.wrapping_mul(39).wrapping_add(76)).map(|x| x.wrapping_mul(40).wrapping_add(76)).map(|x| x.wrapping_mul(41).wrapping_add(76)).map(|x| x.wrapping_mul(42).wrapping_add(76)).fold(0, u64::wrapping_add) } +pub fn busy_77() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(77)).map(|x| x.wrapping_mul(4).wrapping_add(77)).map(|x| x.wrapping_mul(5).wrapping_add(77)).map(|x| x.wrapping_mul(6).wrapping_add(77)).map(|x| x.wrapping_mul(7).wrapping_add(77)).map(|x| x.wrapping_mul(8).wrapping_add(77)).map(|x| x.wrapping_mul(9).wrapping_add(77)).map(|x| x.wrapping_mul(10).wrapping_add(77)).map(|x| x.wrapping_mul(11).wrapping_add(77)).map(|x| x.wrapping_mul(12).wrapping_add(77)).map(|x| x.wrapping_mul(13).wrapping_add(77)).map(|x| x.wrapping_mul(14).wrapping_add(77)).map(|x| x.wrapping_mul(15).wrapping_add(77)).map(|x| x.wrapping_mul(16).wrapping_add(77)).map(|x| x.wrapping_mul(17).wrapping_add(77)).map(|x| x.wrapping_mul(18).wrapping_add(77)).map(|x| x.wrapping_mul(19).wrapping_add(77)).map(|x| x.wrapping_mul(20).wrapping_add(77)).map(|x| x.wrapping_mul(21).wrapping_add(77)).map(|x| x.wrapping_mul(22).wrapping_add(77)).map(|x| x.wrapping_mul(23).wrapping_add(77)).map(|x| x.wrapping_mul(24).wrapping_add(77)).map(|x| x.wrapping_mul(25).wrapping_add(77)).map(|x| x.wrapping_mul(26).wrapping_add(77)).map(|x| x.wrapping_mul(27).wrapping_add(77)).map(|x| x.wrapping_mul(28).wrapping_add(77)).map(|x| x.wrapping_mul(29).wrapping_add(77)).map(|x| x.wrapping_mul(30).wrapping_add(77)).map(|x| x.wrapping_mul(31).wrapping_add(77)).map(|x| x.wrapping_mul(32).wrapping_add(77)).map(|x| x.wrapping_mul(33).wrapping_add(77)).map(|x| x.wrapping_mul(34).wrapping_add(77)).map(|x| x.wrapping_mul(35).wrapping_add(77)).map(|x| x.wrapping_mul(36).wrapping_add(77)).map(|x| x.wrapping_mul(37).wrapping_add(77)).map(|x| x.wrapping_mul(38).wrapping_add(77)).map(|x| x.wrapping_mul(39).wrapping_add(77)).map(|x| x.wrapping_mul(40).wrapping_add(77)).map(|x| x.wrapping_mul(41).wrapping_add(77)).map(|x| x.wrapping_mul(42).wrapping_add(77)).fold(0, u64::wrapping_add) } +pub fn busy_78() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(78)).map(|x| x.wrapping_mul(4).wrapping_add(78)).map(|x| x.wrapping_mul(5).wrapping_add(78)).map(|x| x.wrapping_mul(6).wrapping_add(78)).map(|x| x.wrapping_mul(7).wrapping_add(78)).map(|x| x.wrapping_mul(8).wrapping_add(78)).map(|x| x.wrapping_mul(9).wrapping_add(78)).map(|x| x.wrapping_mul(10).wrapping_add(78)).map(|x| x.wrapping_mul(11).wrapping_add(78)).map(|x| x.wrapping_mul(12).wrapping_add(78)).map(|x| x.wrapping_mul(13).wrapping_add(78)).map(|x| x.wrapping_mul(14).wrapping_add(78)).map(|x| x.wrapping_mul(15).wrapping_add(78)).map(|x| x.wrapping_mul(16).wrapping_add(78)).map(|x| x.wrapping_mul(17).wrapping_add(78)).map(|x| x.wrapping_mul(18).wrapping_add(78)).map(|x| x.wrapping_mul(19).wrapping_add(78)).map(|x| x.wrapping_mul(20).wrapping_add(78)).map(|x| x.wrapping_mul(21).wrapping_add(78)).map(|x| x.wrapping_mul(22).wrapping_add(78)).map(|x| x.wrapping_mul(23).wrapping_add(78)).map(|x| x.wrapping_mul(24).wrapping_add(78)).map(|x| x.wrapping_mul(25).wrapping_add(78)).map(|x| x.wrapping_mul(26).wrapping_add(78)).map(|x| x.wrapping_mul(27).wrapping_add(78)).map(|x| x.wrapping_mul(28).wrapping_add(78)).map(|x| x.wrapping_mul(29).wrapping_add(78)).map(|x| x.wrapping_mul(30).wrapping_add(78)).map(|x| x.wrapping_mul(31).wrapping_add(78)).map(|x| x.wrapping_mul(32).wrapping_add(78)).map(|x| x.wrapping_mul(33).wrapping_add(78)).map(|x| x.wrapping_mul(34).wrapping_add(78)).map(|x| x.wrapping_mul(35).wrapping_add(78)).map(|x| x.wrapping_mul(36).wrapping_add(78)).map(|x| x.wrapping_mul(37).wrapping_add(78)).map(|x| x.wrapping_mul(38).wrapping_add(78)).map(|x| x.wrapping_mul(39).wrapping_add(78)).map(|x| x.wrapping_mul(40).wrapping_add(78)).map(|x| x.wrapping_mul(41).wrapping_add(78)).map(|x| x.wrapping_mul(42).wrapping_add(78)).fold(0, u64::wrapping_add) } +pub fn busy_79() -> u64 { (0..10u64).map(|x| x.wrapping_mul(3).wrapping_add(79)).map(|x| x.wrapping_mul(4).wrapping_add(79)).map(|x| x.wrapping_mul(5).wrapping_add(79)).map(|x| x.wrapping_mul(6).wrapping_add(79)).map(|x| x.wrapping_mul(7).wrapping_add(79)).map(|x| x.wrapping_mul(8).wrapping_add(79)).map(|x| x.wrapping_mul(9).wrapping_add(79)).map(|x| x.wrapping_mul(10).wrapping_add(79)).map(|x| x.wrapping_mul(11).wrapping_add(79)).map(|x| x.wrapping_mul(12).wrapping_add(79)).map(|x| x.wrapping_mul(13).wrapping_add(79)).map(|x| x.wrapping_mul(14).wrapping_add(79)).map(|x| x.wrapping_mul(15).wrapping_add(79)).map(|x| x.wrapping_mul(16).wrapping_add(79)).map(|x| x.wrapping_mul(17).wrapping_add(79)).map(|x| x.wrapping_mul(18).wrapping_add(79)).map(|x| x.wrapping_mul(19).wrapping_add(79)).map(|x| x.wrapping_mul(20).wrapping_add(79)).map(|x| x.wrapping_mul(21).wrapping_add(79)).map(|x| x.wrapping_mul(22).wrapping_add(79)).map(|x| x.wrapping_mul(23).wrapping_add(79)).map(|x| x.wrapping_mul(24).wrapping_add(79)).map(|x| x.wrapping_mul(25).wrapping_add(79)).map(|x| x.wrapping_mul(26).wrapping_add(79)).map(|x| x.wrapping_mul(27).wrapping_add(79)).map(|x| x.wrapping_mul(28).wrapping_add(79)).map(|x| x.wrapping_mul(29).wrapping_add(79)).map(|x| x.wrapping_mul(30).wrapping_add(79)).map(|x| x.wrapping_mul(31).wrapping_add(79)).map(|x| x.wrapping_mul(32).wrapping_add(79)).map(|x| x.wrapping_mul(33).wrapping_add(79)).map(|x| x.wrapping_mul(34).wrapping_add(79)).map(|x| x.wrapping_mul(35).wrapping_add(79)).map(|x| x.wrapping_mul(36).wrapping_add(79)).map(|x| x.wrapping_mul(37).wrapping_add(79)).map(|x| x.wrapping_mul(38).wrapping_add(79)).map(|x| x.wrapping_mul(39).wrapping_add(79)).map(|x| x.wrapping_mul(40).wrapping_add(79)).map(|x| x.wrapping_mul(41).wrapping_add(79)).map(|x| x.wrapping_mul(42).wrapping_add(79)).fold(0, u64::wrapping_add) }