diff --git a/.gitignore b/.gitignore index 41cac8745..84a43ed7c 100644 --- a/.gitignore +++ b/.gitignore @@ -50,3 +50,8 @@ docs/introduction/lessons/searchindex .benchmarks/ *.profraw *.profdata +.julia-runtime/ +.julia-depot/ +julia/LocalPreferences.toml +julia/cuda/LocalPreferences.toml +!julia/metal/LocalPreferences.toml diff --git a/benchmarks/ab.py b/benchmarks/ab.py index f56eb2c02..9bf0923d4 100644 --- a/benchmarks/ab.py +++ b/benchmarks/ab.py @@ -77,14 +77,34 @@ def ab_options(parser: argparse.ArgumentParser) -> None: choices=BACKENDS, help="the candidate arm's backend; default: --backend", ) + parser.add_argument( + "--cooldown", + type=float, + default=0.0, + help="seconds to idle before each worker, so that one worker's heat (a Julia " + "worker's compilation) does not slow the next", + ) + parser.add_argument( + "--device-arm", + choices=("baseline", "candidate"), + help="run only this arm on its device (a GPU against a CPU build); the other " + "runs on the host at the row's width", + ) + +def arm_configuration( + configuration: Record, backend: str, device: bool | None = None +) -> Record: + """Return one arm's configuration: its backend and that backend's precision. -def arm_configuration(configuration: Record, backend: str) -> Record: - """Return one arm's configuration: its backend and that backend's precision.""" + `device`, when given, overrides the row's device flag for this arm alone. + """ return { **configuration, - "backend": backend, - "precision": "single" if backend == "mlx" else "double", + # "julia32" is the julia backend in single precision (the Julia experiment). + "backend": "julia" if backend == "julia32" else backend, + "precision": "single" if backend in ("mlx", "julia32") else "double", + **({} if device is None else {"device": device}), } @@ -203,6 +223,8 @@ def ab(args: argparse.Namespace) -> int: """Collect and summarise a paired comparison of two prepared builds.""" if args.rounds < 1 or args.repeats < 1 or args.timeout <= 0: raise SuiteError("rounds, repeats and timeout must be positive") + if args.device_arm is not None and args.device: + raise SuiteError("--device runs both arms on a device; --device-arm one") started = time.perf_counter() backends = { "baseline": args.baseline_backend or args.backend, @@ -260,12 +282,16 @@ def ab(args: argparse.Namespace) -> int: for row in shuffled: width = row["configuration"]["threads"] for arm in arm_order(round_index): + if args.cooldown > 0: + time.sleep(args.cooldown) quiet = guard(allocation)["quiet"] events, elapsed = launch_worker( pythons[arm], { "configuration": arm_configuration( - row["configuration"], backends[arm] + row["configuration"], + backends[arm], + None if args.device_arm is None else arm == args.device_arm, ), "repeats": args.repeats, "fields": str( diff --git a/benchmarks/registry.py b/benchmarks/registry.py index 72a581887..9752e6faa 100644 --- a/benchmarks/registry.py +++ b/benchmarks/registry.py @@ -139,14 +139,16 @@ def configuration( # noqa: PLR0913 - the shared command-line selection raise SuiteError(f"{self.name} admits only {', '.join(self.steppers)}") if not 0 < fraction <= 1 or not 0 <= warmup < 1: raise SuiteError("length fraction must be in (0, 1], warm-up in [0, 1)") + # "julia32" is the julia backend in single precision (the Julia experiment). + single = backend in ("mlx", "julia32") return { "case": self.name, "revision": self.revision, "case_hash": self.digest, "stepper": stepper, "threads": width, - "backend": backend, - "precision": "single" if backend == "mlx" else "double", + "backend": "julia" if backend == "julia32" else backend, + "precision": "single" if single else "double", "noise": noise, "fft_size": fft_size, "device": device, diff --git a/benchmarks/system.py b/benchmarks/system.py index 2d28b28f3..13f7388ca 100644 --- a/benchmarks/system.py +++ b/benchmarks/system.py @@ -54,6 +54,9 @@ "SOLPROP_NATIVE_RAMAN_FFT_THREADS", "SOLPROP_NATIVE_RAMAN_TAIL_FFT_THREADS", "SOLPROP_NATIVE_THREADED_FFT_MIN_SAMPLES", + "SOLPROP_JULIA_THREADS", + "SOLPROP_JULIA_FFT_THREADS", + "SOLPROP_JULIA_BLAS_THREADS", "SOLPROP_BLAS_THREADS", "OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", @@ -279,6 +282,7 @@ def thread_environment( for key in ( "SOLPROP_THREADS", "SOLPROP_NATIVE_THREADS", + "SOLPROP_JULIA_THREADS", "OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", @@ -292,6 +296,8 @@ def thread_environment( "SOLPROP_NATIVE_FFT_THREADS", "SOLPROP_NATIVE_RAMAN_FFT_THREADS", "SOLPROP_NATIVE_RAMAN_TAIL_FFT_THREADS", + "SOLPROP_JULIA_FFT_THREADS", + "SOLPROP_JULIA_BLAS_THREADS", "SOLPROP_BLAS_THREADS", ): environment[key] = "1" diff --git a/benchmarks/track.py b/benchmarks/track.py index a41a64721..63ef66717 100644 --- a/benchmarks/track.py +++ b/benchmarks/track.py @@ -36,8 +36,9 @@ thread_environment, ) -BACKENDS = ("numpy_ref", "native", "mlx") -"""The backends a benchmark can name; ``mlx`` only on an Apple GPU.""" +BACKENDS = ("numpy_ref", "native", "mlx", "julia", "julia32") +"""The backends a benchmark can name; ``mlx`` only on an Apple GPU, ``julia32`` the +julia backend in single precision.""" REPEAT_TOLERANCE = 1e-9 """The relative L2 difference two repeats' final fields may have: rounding only.""" diff --git a/benchmarks/worker.py b/benchmarks/worker.py index d4eabf818..0860b6fcb 100644 --- a/benchmarks/worker.py +++ b/benchmarks/worker.py @@ -19,6 +19,7 @@ import importlib import importlib.metadata import logging +import os import sys import time import traceback @@ -60,8 +61,25 @@ def emit(kind: str, **values: object) -> None: - """Flush a protocol event; the parent reads it after the worker exits.""" - print(canonical({"event": kind, **values}), flush=True) + """Flush a protocol event; the parent reads it after the worker exits. + + An embedded runtime can leave the inherited pipe nonblocking (Julia's libuv + does), and a large event then stops short; it is written in blocking mode. + """ + descriptor = None + blocking = True + try: + descriptor = sys.stdout.fileno() + blocking = os.get_blocking(descriptor) + except OSError, ValueError: + pass # In-memory output capture has no operating-system descriptor. + if descriptor is not None and not blocking: + os.set_blocking(descriptor, True) + try: + print(canonical({"event": kind, **values}), flush=True) + finally: + if descriptor is not None and not blocking: + os.set_blocking(descriptor, False) HOST_SPACES = ("OpenMP", "Threads", "Serial") @@ -75,8 +93,18 @@ def runtime(backend: str, device: bool = False) -> Record: other run needs a CPU build. """ info: Record = {} - if device and backend != "native": - raise SuiteError("only the native backend runs on a device") + if device and backend not in {"native", "julia"}: + raise SuiteError("only the native and julia backends run on a device") + if backend == "julia": + # The Julia experiment runs on its CUDA device under --device; its sources + # are identified by digest, as a native build is by its extension's. + # A GPU run takes the GPU the environment names (rocm on AMD), else CUDA. + named = os.environ.get("SOLPROP_JULIA_DEVICE") + gpu = named if named in {"cuda", "rocm", "metal"} else "cuda" + os.environ["SOLPROP_JULIA_DEVICE"] = gpu if device else "cpu" + from solprop.backends.julia import source_digest # noqa: PLC0415 + + info["julia_build"] = source_digest() if backend == "native": # solprop_native must be imported before any other OpenMP runtime. import solprop_native # noqa: PLC0415 # pyright: ignore[reportMissingImports] @@ -96,7 +124,7 @@ def runtime(backend: str, device: bool = False) -> Record: import solprop # noqa: PLC0415 packages = {} - for name in ("solprop", "numpy", "scipy", "optmat", "mlx"): + for name in ("solprop", "numpy", "scipy", "optmat", "mlx", "juliacall"): try: packages[name] = importlib.metadata.version(name) except importlib.metadata.PackageNotFoundError: @@ -201,13 +229,17 @@ def timed_run( engine.set_initial(problem.initial.field0, None, z=problem.initial.z) output = MemoryOutput() + # The run's record before the clock starts: its first evaluation builds the planes' + # bases (about 0.18 s on rdw), which every arm's first repeat would otherwise pay + # inside its window. + metadata = simulation.metadata() before = source_calls(engine) started = time.perf_counter_ns() run_problem( problem, engine, output, - metadata=simulation.metadata(), + metadata=metadata, stats_spec=problem.stats_spec, progress="none", resume_history=simulation.settings.resume_history, @@ -232,7 +264,7 @@ def timed_run( def _device_free(configuration: Record) -> int | None: """Read the accelerator's free bytes on a device run, else ``None``.""" - if not configuration.get("device"): + if not configuration.get("device") or configuration["backend"] != "native": return None import solprop_native # noqa: PLC0415 # pyright: ignore[reportMissingImports] diff --git a/changelog.d/julia-backend-experiment.added.md b/changelog.d/julia-backend-experiment.added.md new file mode 100644 index 000000000..3f4ce88a9 --- /dev/null +++ b/changelog.d/julia-backend-experiment.added.md @@ -0,0 +1 @@ +An experimental `julia` backend (`backend="julia"`, the `julia` extra and a Julia 1.13 runtime prepared by `julia/bootstrap.py`) runs the scalar modal capillary, mode-averaged, radial, Cartesian and line routes on a CPU, or on an NVIDIA GPU with `SOLPROP_JULIA_DEVICE=cuda`, in binary64 or binary32, from one Julia source. It is an experiment, not a supported backend: `julia/STATUS.md` lists what it runs and refuses, and the [manual page](docs/guide/performance/julia.md) how to try it. diff --git a/coverage-cpu.ini b/coverage-cpu.ini index 388178712..cf78ad4f7 100644 --- a/coverage-cpu.ini +++ b/coverage-cpu.ini @@ -13,6 +13,7 @@ source = solprop branch = True omit = */solprop/backends/mlx_gpu/* + */solprop/backends/julia/* [report] fail_under = 100 diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 61c0f0c39..4949fde21 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -2902,3 +2902,549 @@ a 768 × 768 × 600 envelope launch through a Sellmeier glass with a Kerr respon A launch's bits don't change, which `tests/test_pulses.py` and `tests/test_cartesian_precision.py` hold across thread counts. The sum that scales the field stays one sum in one order for that reason, so it stays on one thread. + +## Julia backend experiment + +The experimental `julia` backend (`julia/STATUS.md`) against `native`, both arms in one +interpreter, `python -m benchmarks ab --baseline-backend native --candidate-backend julia +--noise none --length 0.02 --stepper default`: 2 % of each case, so ten to two hundred +steps and the cases' 4 to 12 saved planes; the ratio is `julia`/`native`, below one +`julia` faster. Every binary64 row took the same steps on both arms, with fields equal +to 1e-13 or better. These are short windows, not whole runs. + +Rows before commit `3969a00c`'s harness fix (#557) timed `simulation.metadata()` inside +the window, about 0.18 s on `rdw`, on both arms: they understate both arms' speed and +overstate how close `julia` was. Native's `rdw` window on 16 Xeon threads is 0.145 s, +not 0.314 s; on the A40 0.054 s, not 0.187 s. + +**Intel Xeon Gold 6240**, 16 cores of socket 1 with their 16 threads, passive-bound +threading, a shared machine (load 2 to 14 during the run), two rounds, commit +`7c7ac9b7`: + +| case | native 1 thread, s | julia | ratio | native 16 threads, s | julia | ratio | +|---|---:|---:|---:|---:|---:|---:| +| `rdw` | 0.416 | 0.586 | 1.41 | 0.159 | 0.161 | 1.03 | +| `argon_blueshift` | 0.546 | 1.317 | 2.41 | 0.225 | 0.386 | 1.79 | +| `h2_raman_6ps` | 3.896 | 3.910 | 1.02 | 2.609 | 2.735 | 1.13 | +| `ctc_reduced` | 0.995 | 1.743 | 1.75 | 0.377 | 0.379 | 1.01 | +| `radial_filament_256` | 2.150 | 2.329 | 1.08 | 0.364 | 0.779 | 2.14 | +| `kerr_beam_192` | 5.177 | 5.907 | 1.14 | 0.851 | 1.424 | 1.67 | +| `line` | 0.674 | 0.875 | 1.30 | 0.202 | 0.352 | 1.78 | + +Geometric mean 1.42. The rounds of `argon_blueshift` (1.4 to 2.2 on 16 threads) and +`h2_raman_6ps` (0.8 to 1.4) spread with the machine's load. At commit `09a60bf6`, +before the vectorised plasma and the batched transforms, the same plan gave 1.64. The +next commit, `207add18`, runs the Adams march in the engine: `argon_blueshift` on 16 +threads 0.42 s -> 0.34 s and `rdw` 0.157 -> 0.148 s (single profiled runs, socket 0). + +Later, the same plan at commit `50158fa6` (the Julia march, the spatial statistics, the +pooled copies, the thin products and the rest of the CPU changes), three rounds, the +machine quiet at the start and at load 11 to 14 by the end: + +| case | native 1 thread, s | julia | ratio | native 16 threads, s | julia | ratio | +|---|---:|---:|---:|---:|---:|---:| +| `rdw` | 0.418 | 0.681 | 1.54 | 0.189 | 0.216 | 1.14 | +| `argon_blueshift` | 0.545 | 0.961 | 1.77 | 0.186 | 0.249 | 1.30 | +| `h2_raman_6ps` | 3.385 | 4.254 | 1.25 | 2.871 | 1.743 | 0.86 | +| `ctc_reduced` | 1.012 | 1.871 | 1.85 | 0.377 | 0.381 | 1.01 | +| `radial_filament_256` | 2.163 | 2.222 | 1.02 | 0.368 | 0.564 | 1.52 | +| `kerr_beam_192` | 5.147 | 5.824 | 1.12 | 0.996 | 1.119 | 1.11 | +| `line` | 0.679 | 0.821 | 1.20 | 0.185 | 0.212 | 1.17 | + +Geometric mean 1.25 (1.42 at `7c7ac9b7`). The load spread some rounds widely +(`h2_raman_6ps` 0.59 to 0.88 and `kerr_beam_192` 0.67 to 1.35 on 16 threads); the +ratios are medians of paired rounds, both arms under the same load. + +And at commit `a6722029`, three rounds on a quiet machine (load 0.3 to 2.2). Until this +commit every Julia row above carried compilation inside its window: the worker's +warm-up runs without a boundary monitor, so the monitor's bindings and radial's split +collar first ran, and compiled, in the timed run (252 ms of a radial window, 80 ms of +`line`'s, 97 ms of `kerr_beam_192`'s). The construction now warms them +(`test_julia_first_window_compiles_nothing`): + +| case | native 1 thread, s | julia | ratio | native 16 threads, s | julia | ratio | +|---|---:|---:|---:|---:|---:|---:| +| `rdw` | 0.416 | 0.632 | 1.52 | 0.143 | 0.148 | 1.04 | +| `argon_blueshift` | 0.544 | 0.839 | 1.51 | 0.181 | 0.219 | 1.21 | +| `h2_raman_6ps` | 3.395 | 4.216 | 1.24 | 1.923 | 1.714 | 0.89 | +| `ctc_reduced` | 1.007 | 1.573 | 1.56 | 0.378 | 0.344 | 0.90 | +| `radial_filament_256` | 2.157 | 2.111 | 0.97 | 0.367 | 0.407 | 1.12 | +| `kerr_beam_192` | 5.149 | 5.671 | 1.10 | 0.851 | 1.070 | 1.26 | +| `line` | 0.675 | 0.730 | 1.08 | 0.181 | 0.141 | 0.78 | + +Geometric mean 1.13; Julia faster than native in four rows. + +**NVIDIA A40** (driver 595.71), native's CUDA build (AMPERE86) against `julia` with +`SOLPROP_JULIA_DEVICE=cuda` (CUDA.jl 6.5), `--device`, two rounds, commit `7c7ac9b7`: + +| case | native, s | julia binary64, s | ratio | julia binary32, s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.054 | 0.168 | 3.13 | 0.181 | 3.38 | +| `argon_blueshift` | 0.115 | 0.444 | 3.85 | 0.313 | 2.72 | +| `h2_raman_6ps` | 1.040 | 1.310 | 1.26 | 1.005 | 0.96 | +| `ctc_reduced` | 0.206 | 0.386 | 1.87 | 0.352 | 1.71 | +| `radial_filament_256` | 0.169 | 0.628 | 3.73 | 0.547 | 3.24 | +| `kerr_beam_192` | 0.173 | 0.618 | 3.58 | 0.611 | 3.50 | +| `line` | 0.094 | 0.311 | 3.30 | 0.294 | 3.12 | + +Geometric means 2.77 (binary64) and 2.45 (binary32 against native's binary64; its +fields within 4e-7 to 1.4e-5 of native's, and `rdw`, `ctc_reduced` and the radial +window take other steps). At `90840a43`, with the metadata inside the window, the +binary64 mean was 2.54 and `rdw` 0.356 s. What remains on the A40, from Nsight +Systems (`rdw`, commit `7c7ac9b7`): the device is busy for about 124 ms of the 0.168 s +window. Nine transforms a source at 96 us each (over four modes, so a few blocks each: +latency, not work) are a third; the Adams predictor's reduction, heavy binary64 work a +sample on too few threads, 539 us a trial; then the plasma and Kerr passes. + +At commit `cfa14ce7` (the Julia march; the GPU's heavy reductions a thread an element and +its transforms in batches) the same plan gave, binary64 then binary32: + +| case | native, s | julia binary64, s | ratio | julia binary32, s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.054 | 0.137 | 2.53 | 0.182 | 3.27 | +| `argon_blueshift` | 0.117 | 0.338 | 2.89 | 0.280 | 2.39 | +| `h2_raman_6ps` | 1.040 | 1.180 | 1.14 | 0.674 | 0.65 | +| `ctc_reduced` | 0.207 | 0.323 | 1.56 | 0.317 | 1.53 | +| `radial_filament_256` | 0.173 | 0.513 | 2.97 | 0.408 | 2.37 | +| `kerr_beam_192` | 0.198 | 0.648 | 3.28 | 0.673 | 3.52 | +| `line` | 0.095 | 0.271 | 2.84 | 0.213 | 2.20 | + +Geometric means 2.32 and 2.03. One binary32 `argon_blueshift` round hung until the +worker's timeout (the other ran at 2.39); `rdw`'s binary64 field differed from native's +by 1.8e-11, the reordered reduction of the Adams norms, with the same steps. + +At `50158fa6` (the GPU's device reductions) binary64 gave 2.19 and binary32 1.99, and at +`3fd4a09f` (radial on the engine's march, the GPU's scratch kept) 2.27 and 2.03 on +another A40 node. Radial's window rose from 0.479 s to 0.530 s there, outside both +spreads, while `rdw` and `line`, which those commits did not change, rose too (0.129 to +0.136 s, 0.247 to 0.258 s): whether the march costs radial on a GPU is not established. +Binary32 `h2_raman_6ps` at 0.61. No window hung in either. + +At `a6722029` (the first window no longer compiling) binary64 gave 1.97: `rdw` 2.86, +`argon_blueshift` 2.80, `h2_raman_6ps` 1.02, `ctc_reduced` 1.47, radial 2.05 (0.354 s), +`kerr_beam_192` 2.75, `line` 1.68. The binary32 arm of the same job was erratic (`rdw`'s +rounds 2.5 and 20.9 against steady native times); rerun on another node (its host load +about 12 from other jobs), three rounds, it gave `rdw` 2.48, radial 1.39 (0.233 s), +`ctc_reduced` 1.37 and `line` 1.59: the Julia arm's host work makes it the more +sensitive to a busy node. + +**NVIDIA H200** (a rented droplet, CUDA 13.1, driver 580.196), native's CUDA build +(HOPPER90) against `julia` with CUDA.jl on the system toolkit (`bootstrap.py +--cuda-local`), `--device`, two rounds, binary64, commit `50158fa6`; every row took +native's steps with its fields to rounding: + +| case | native, s | julia, s | ratio | +|---|---:|---:|---:| +| `rdw` | 0.036 | 0.073 | 2.02 | +| `argon_blueshift` | 0.066 | 0.169 | 2.56 | +| `h2_raman_6ps` | 0.217 | 0.426 | 1.96 | +| `ctc_reduced` | 0.067 | 0.134 | 1.98 | +| `radial_filament_256` | 0.058 | 0.257 | 4.42 | +| `kerr_beam_192` | 0.181 | 0.307 | 1.69 | +| `line` | 0.058 | 0.170 | 2.92 | + +Geometric mean 2.39. On a GPU with full-rate binary64 the windows are host-bound: Nsight +Systems finds radial's kernels about 26 ms of its 0.257 s window, against 4800 launches, +670 device-to-host copies and 2300 pool allocations for two runs, and radial's split +collar keeps the Python march. Without `--cuda-local` CUDA.jl's own cuBLAS met the +system one native had loaded and every modal window crashed. + +**AMD Instinct MI325X** (a rented droplet, ROCm 10.0), native's HIP build (gfx942) +against `julia` with `SOLPROP_JULIA_DEVICE=rocm` (AMDGPU.jl 2.11), `--device`, two +rounds, commit `196baa51`. The first run of the AMDGPU extension: the device tests +pass (binary64 against `numpy_ref` to 1e-10, binary32 to 1e-4), and every binary64 row +took native's steps with its fields to rounding. + +| case | native, s | julia binary64, s | ratio | julia binary32, s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.027 | 0.055 | 2.03 | 0.088 | 3.27 | +| `argon_blueshift` | 0.057 | 0.134 | 2.33 | 0.124 | 2.16 | +| `h2_raman_6ps` | 0.231 | 0.395 | 1.71 | 0.364 | 1.57 | +| `ctc_reduced` | 0.061 | 0.138 | 2.27 | 0.129 | 2.09 | +| `radial_filament_256` | 0.046 | 0.224 | 4.85 | 0.188 | 3.99 | +| `kerr_beam_192` | 0.076 | 0.260 | 3.44 | 0.347 | 4.50 | +| `line` | 0.056 | 0.106 | 1.89 | 0.112 | 2.04 | + +Geometric means 2.48 (binary64) and 2.62 (binary32 against native's binary64). A +`rocprofv3` trace of the radial window found the column-at-a-thread passes (the local +statistics' sums, the monitor's row and column sums) and the occupancy's atomics on a +crossing's few buckets the largest kernels; commit `50158fa6` forms them as device +reductions. + +**Apple M5 Max** (6 top-tier and 12 second-tier cores, 128 GB, macOS 27; native built on +the NEON FFTW 3.3.11 prefix with Accelerate's BLAS), three rounds on a quiet machine, +commit `3933d4f3` (the engine as measured above; Julia's BLAS is OpenBLAS). The first +measurement of the rewritten engine on this machine: + +| case | native 1 thread, s | julia | ratio | native 6, s | julia | ratio | native 18, s | julia | ratio | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| `rdw` | 0.196 | 0.222 | 1.17 | 0.085 | 0.072 | 0.88 | 0.110 | 0.067 | 0.61 | +| `argon_blueshift` | 0.355 | 0.303 | 0.86 | 0.134 | 0.106 | 0.79 | 0.135 | 0.114 | 0.86 | +| `h2_raman_6ps` | 1.433 | 1.478 | 1.03 | 0.804 | 0.653 | 0.81 | 1.038 | 0.925 | 0.82 | +| `ctc_reduced` | 0.669 | 0.573 | 0.84 | 0.207 | 0.158 | 0.76 | 0.214 | 0.163 | 0.76 | +| `radial_filament_256` | 0.914 | 1.030 | 1.12 | 0.322 | 0.291 | 0.90 | 0.302 | 0.260 | 0.86 | +| `kerr_beam_192` | 1.662 | 1.555 | 0.92 | 0.528 | 0.475 | 0.90 | 0.443 | 0.337 | 0.76 | +| `line` | 0.219 | 0.266 | 1.23 | 0.114 | 0.078 | 0.68 | 0.183 | 0.070 | 0.38 | + +Geometric mean 0.83: Julia faster in 16 of 21 rows, every row on native's steps with +fields equal to 1e-13 or better. Native is slower on 18 threads than on 6 in four +cases (`h2_raman_6ps` 0.80 -> 1.04 s, `line` 0.11 -> 0.18 s, `rdw`, `ctc_reduced`): the +second-tier cores hold back its parallel regions. Julia's tasks lose less there. + +**Apple M5 Max GPU** (40 cores, Metal 4; Metal.jl 1.12), `julia` in binary32 with +`SOLPROP_JULIA_DEVICE=metal` and the double-float wide type (`julia/src/dfloat.jl`), +commit `ecbcafbe`, `--device-arm candidate`. Against native's binary64 on 6 CPU threads, +three rounds, the cases' own transform sizes; and against `mlx` (binary32, +`MLX_ENABLE_TF32=0`), two rounds, `--fft-size pow2`: + +| case | native 6 threads, s | julia Metal, s | ratio | mlx, s | julia Metal, s | ratio | +|---|---:|---:|---:|---:|---:|---:| +| `rdw` | 0.091 | 0.359 | 3.95 | 0.453 | 0.523 | 1.16 | +| `argon_blueshift` | 0.137 | 0.868 | 6.35 | 0.530 | 0.890 | 1.68 | +| `h2_raman_6ps` | 0.797 | 1.574 | 1.97 | 0.916 | 1.939 | 2.12 | +| `ctc_reduced` | 0.213 | 0.723 | 3.42 | 1.115 | 1.062 | 0.96 | +| `radial_filament_256` | 0.306 | 0.278 | 0.92 | 0.318 | 0.271 | 0.96 | +| `kerr_beam_192` | 0.539 | 0.176 | 0.33 | 0.286 | 0.200 | 0.71 | +| `line` | 0.112 | 0.231 | 2.09 | 0.134 | 0.241 | 1.80 | + +Geometric means 1.95 against native's CPU and 1.25 against `mlx`. The binary32 fields +are 4e-7 to 2e-5 from native's binary64 and 1e-6 to 2e-5 from `mlx`'s. The GPU wins +where the state is large (the Cartesian beam three times native's six cores, radial at +par) and loses where it is a capillary's few modes, whose windows are launch-bound; +`argon_blueshift`'s plasma takes the per-sample GPU path. Metal.jl's probes on this GPU: +every FFT plan form the engine uses (in-place, dimension 1 of a matrix, odd `brfft`, +dims (2, 3)) works, without MLX's Bluestein cliff (10240 points as fast as 8192), at +2 to 5e-7; Float32 GEMM is full precision (1.5e-7, not TF32) on real views; the +two-sum and fused two-product survive compilation. Construction compiles the Metal +kernels: about 28 s, with no precompiled trace for the device yet. + +The same M5 Max, later commits: + +- **Whole runs** (commit `3f0d33d6`, the full guides, 6 threads, two rounds): `julia` over + native 0.86 (`rdw`, 2.33 s native), 0.74 (`argon_blueshift`, 5.69 s), 0.95 (radial, + 0.94 s), 1.02 (`kerr_beam_192`, 1.59 s), 0.71 (`ctc_reduced`, 6.12 s), 0.82 + (`h2_raman_6ps`, 63.2 s) and 0.68 (`line`, 0.14 s); geometric mean 0.82, every round + within 0.3 %, the same steps, fields 1e-11 to 1e-15 apart. +- **Accelerate for Julia's products** (`SOLPROP_JULIA_BLAS=accelerate` against + OpenBLAS 0.3.30, commit `e99851d5`, three rounds): radial 0.59 on one thread and 0.82 + on six, `h2_raman_6ps` 0.88 on six, every other row 0.97 to 1.05 within its rounds' + spread; geometric mean 0.94. Commit `d872cb59` makes it the default on macOS. +- **Contraction** (commit `3f0d33d6`'s fused multiply-adds against `ecbcafbe`, binary64, + three rounds): geometric mean 0.99, `h2_raman_6ps` 0.96 and 0.93 the only steady gain; + fields 1e-13 apart, the same steps. +- **Flush-to-zero** (`SOLPROP_JULIA_FTZ=1`, an experiment the policy forbids, #561): + binary32 0.997 and binary64 0.99, nothing beyond the rounds' spread but + `ctc_reduced` on six threads (0.88). Apple's cores take subnormals at full speed. +- **Native's thread count.** Native's 2 % windows on 1 to 18 threads (OpenMP default + and `active` waiting alike) are fastest on the six top-tier cores for `rdw`, radial, + `h2_raman_6ps` and `line`, and on 12 for `kerr_beam_192` and `ctc_reduced`; eight + threads, two of them second-tier, are already slower than six, and 18 take 1.4 to 1.5 + times six's time (`h2_raman_6ps` 0.61 -> 0.91 s). +- **The machine's state.** Absolute times on the Mac moved by up to 40 % over the day + with no thermal warning recorded: native's six-thread `rdw` window took 0.062 s in + the thread scan and 0.083 to 0.092 s in every later run, native alone (two A/A + passes), beside Julia workers, after 15 s of every core busy, or with 30 s idle before + each worker (`benchmarks ab --cooldown`, commit `d872cb59`). A suspicion: sustained + load slows the whole machine. Interleaved arms share the state, and the ratio held + through all of it: with the cooldown 0.79 (`line` 0.62 to the Cartesian beam 0.93), + and back-to-back single-backend passes 0.72 to 0.92 by case. + +**NVIDIA A40** (DMOG, driver 595.71), commit `ecbcafbe`, `--device`: the device tests +pass (34, binary32 in both wide types). `julia` binary32 with the double-float wide +type against binary64, three rounds: geometric mean 0.99, the free-space rows 0.88 +(`kerr_beam_192`) and 0.91 (`line`) from forming the operator's elements once on the +host, the rest within their rounds. Against native's CUDA build (binary64), two rounds: + +| case | native, s | julia binary32 df32, s | ratio | +|---|---:|---:|---:| +| `rdw` | 0.054 | 0.230 | 4.26 | +| `argon_blueshift` | 0.116 | 0.254 | 2.19 | +| `h2_raman_6ps` | 1.042 | 0.644 | 0.62 | +| `ctc_reduced` | 0.207 | 0.285 | 1.38 | +| `radial_filament_256` | 0.169 | 0.246 | 1.46 | +| `kerr_beam_192` | 0.174 | 0.488 | 2.80 | +| `line` | 0.094 | 0.127 | 1.35 | + +Geometric mean 1.72 (1.99 for binary32 in the binary64 wide type at `50158fa6`): the +A40's slow binary64 in the operator and phi functions was not what held binary32 back. + +**Intel Xeon Gold 6240** (16 cores of a socket, exclusive), flush-to-zero in binary32, +commit `3f0d33d6`, three rounds: geometric mean 0.99, every row within its rounds' +spread on one thread and on 16 (radial 0.89 on 16 the largest move). The binary32 +windows here take 2 to 3 times binary64's (`rdw` on one thread 1.43 s, 0.63 s in +binary64 at `a6722029`), and flushing subnormals does not change that: they are not +the cause. +- **Metal, strided products copied first** (commit after `be94de60`, two rounds, + `--device`, pow2): on a GPU `gemm!` copies an operand that is a row range of a matrix + into scratch before the product, since Metal.jl takes a generic kernel for one (about + 240 us for 16384 x 36 x 8 against 65 to 140 us copied). `h2_raman_6ps` 1.92 -> 1.45 s + (0.76; its Raman nodal products and projections), radial 0.91, the rest within their + rounds; the same steps. Against `mlx`'s 0.92 s, `h2_raman_6ps` is about 1.6, not 2.1. + +**Metal tuning, 2026-11-07 evening** (M5 Max GPU, `julia32` with df32, `--device`, 4 host +threads, 2 % windows; each change against its parent, three rounds unless said). The +counters (`SOLPROP_JULIA_COUNT=1`) and probes found the costs: a `copyto!` into or out of +a view took about 200 us on Metal (a staged FFT batch 1.6 ms against 0.11 ms for three +transforms), each switch between the engine's kernels and MPS/MPSGraph work about 30 us, +each value the host waits for about 0.2 ms. + +| change | commit | geometric mean | largest effects | +|---|---|---:|---| +| a chunk's constant projection rows kept contiguous | `da5559f0` | 0.93 (two rounds) | `ctc_reduced` 0.74, `argon_blueshift` 0.84 | +| device copies as one kernel, views included | `37aed946` | 0.81 | `rdw` 0.61, `argon_blueshift` 0.71, `ctc_reduced` 0.75 | +| one value the host waits for a step | `5df088ec` | about 0.95 | `h2_raman_6ps` 0.80, `argon_blueshift` 0.82, `rdw` 0.88 (a loaded machine; reruns) | +| one chunk of nodes a source on a GPU | `a38097f8` | 0.84 | `ctc_reduced` 0.61, `h2_raman_6ps` 0.72, radial 0.88 | +| the trial's tables in one upload | `fbd75c2c` | 0.99 | within the rounds | + +Against `mlx` at `fbd75c2c` (binary32, `MLX_ENABLE_TF32=0`, pow2, three rounds; this +morning 1.25): + +| case | `mlx`, s | julia Metal, s | ratio | +|---|---:|---:|---:| +| `rdw` | 0.405 | 0.166 | 0.41 | +| `argon_blueshift` | 0.389 | 0.281 | 0.73 | +| `h2_raman_6ps` | 0.896 | 0.682 | 0.76 | +| `ctc_reduced` | 0.926 | 0.238 | 0.26 | +| `radial_filament_256` | 0.203 | 0.185 | 0.91 | +| `kerr_beam_192` | 0.249 | 0.191 | 0.77 | +| `line` | 0.132 | 0.199 | 1.49 | + +Geometric mean 0.67: Julia faster than `mlx` in six of seven cases, fields 4e-7 to 2e-5 +apart (binary32 against binary32). + +**NVIDIA A40** at `5df088ec` (the first three changes): against `ecbcafbe` 0.97 in +binary64 (the view copies were Metal's problem); against native, binary64 1.88 (1.97 +before; `h2_raman_6ps` 1.00, `ctc_reduced` 1.44, `kerr_beam_192` 2.97) and binary32 with +df32 1.51 (1.72 before; `h2_raman_6ps` 0.58, radial 1.29). + +**NVIDIA A40, Nsight Systems** at `fbd75c2c` (binary64, one warmed 2 % window inside +`cudaProfilerStart`/`Stop`, `scripts/prof_case.py` on DMOG): one-chunk and the packed +tables against `5df088ec` gave 0.95 (`h2_raman_6ps` 0.90, `ctc_reduced` 0.91). A first +profile counted native's kernels at a fraction of Julia's (`rdw` 15 ms against 80, +`h2_raman_6ps` 117 against 868), but native runs each Adams source inside a CUDA graph +(`graph::Region`, `native/src/general.cpp:8219`), which Nsight traces as one unit by +default: those counts left out native's sources and are not comparable. A rerun traces +the graph's nodes (`--cuda-graph-trace=node`). What the code shows directly is that +native's sources do fewer transforms: the analytic signal by one c2c inverse of the +doubled one-sided spectrum (Julia: a c2r, then an fft/bfft pair), the forward streams +packed into one r2c, radial's three streams in one r2c with stacked projections; +`h2_raman_6ps`'s Raman is an FFT convolution of 2 n_t on both. + +**NVIDIA A40** at `137c6915` (the free-space operator as host-formed tables on every +GPU, binary64 too, and the fused Kerr pass restored for Kerr alone; DMOG gpu07, 2 % +windows, 3 rounds): against `9d814979` 0.97 in binary64 (`line` 0.88, `kerr_beam_192` +0.91, the rest within 2 %, fields identical or to 1e-15). Against native, binary64 1.81: + +| case | native / s | julia / s | ratio | julia32 df32 / s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.054 | 0.119 | 2.19 | 0.132 | 2.43 | +| `argon_blueshift` | 0.116 | 0.278 | 2.40 | 0.223 | 1.92 | +| `h2_raman_6ps` | 1.040 | 0.952 | 0.92 | 0.577 | 0.55 | +| `ctc_reduced` | 0.207 | 0.264 | 1.28 | 0.257 | 1.24 | +| `radial_filament_256` | 0.169 | 0.306 | 1.81 | 0.227 | 1.34 | +| `kerr_beam_192` | 0.176 | 0.578 | 3.29 | 0.506 | 3.02 | +| `line` | 0.096 | 0.163 | 1.71 | 0.112 | 1.18 | + +Binary32 with df32 1.48 (2 rounds). + +**NVIDIA A40, the Cartesian transverse transform** through a transverse-first copy +(`Transposed`, against cuFFT's strided planes, the same tree, `SOLPROP_JULIA_TRANSPOSE` +arms, 3 rounds): binary64 `kerr_beam_192` 0.92 (0.88–0.97), `line` 0.89 (0.77–0.96); +binary32 df32 0.88 and 1.00. On the M5 Max GPU (Metal, binary32) the copies cost more +than they save: `kerr_beam_192` 1.10, `line` 1.09, so only CUDA takes them. + +**cuFFT's long binary64 transforms** (A40, `scripts/fft_sizes.jl`, `fft_strided.jl`, +`fft_fourstep2.jl` on DMOG): a 5120-point c2c 96 us and a 10240-point one 138 us at +batches 1 to 12, r2c 50 and 101 (cuFFT 12.4 from CUDA 13.4 and 11.3 from 12.8 alike; +binary32 r2c 7 to 9 us). A 2D 512 x 10 transform is 12 us. The four-step split +(`LongFFT`) takes 23 us at 5120 (256 x 20) and 23 to 25 at 10240 (512 x 20), errors +about 1e-17 of the largest value. + +**NVIDIA A40, inlined kernel bodies** (jl21, `db522ea3` against the same with +`@inline f(t, m)` in the GPU kernel and the reductions through it; two trees, 3 +rounds, binary64): 0.70. `rdw` 0.64, `argon_blueshift` 0.59, radial 0.64, +`kerr_beam_192` 0.80, `ctc_reduced` 0.55, `h2_raman_6ps` 0.68, `line` 1.14 (range +1.06–1.97, fields identical; noisy in every run that day). Left to the inliner, a body +of a few operations was a device call a sample with its arguments in local memory: a +1.08 M-sample cube took 296 us against a broadcast's 34, and 33 inlined (binary32 270 +against 13; `scripts/each_cost3.jl`). On the M5 Max GPU the change is neutral (1.01, +fields identical): Apple's compiler inlines them itself. The four-step transforms +alone (jl20, the same day): 0.99 (`argon_blueshift` 0.94, `ctc_reduced` 0.92); native +against Julia at `db522ea3` 1.80 in binary64. + +**NVIDIA A40 against native at `8765b584`** (inlined bodies; jl21, 2026-11-08, 3 rounds +binary64, 2 binary32): + +| case | native / s | julia / s | ratio | julia32 df32 / s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.054 | 0.074 | 1.39 | 0.074 | 1.32 | +| `argon_blueshift` | 0.115 | 0.157 | 1.37 | 0.182 | 1.58 | +| `h2_raman_6ps` | 1.039 | 0.647 | 0.62 | 0.339 | 0.33 | +| `ctc_reduced` | 0.206 | 0.131 | 0.63 | 0.101 | 0.49 | +| `radial_filament_256` | 0.168 | 0.247 | 1.47 | 0.171 | 1.02 | +| `kerr_beam_192` | 0.171 | 0.501 | 2.85 | 0.338 | 1.98 | +| `line` | 0.093 | 0.148 | 1.59 | 0.135 | 1.43 | + +Geometric means 1.26 (binary64) and 1.00 (binary32 df32); the morning's, at `db522ea3`, +1.80 and 1.56. Nsight on `rdw` at the same commit: Julia's kernels 31.1 ms against +native's 31.7, so what is left there is the host's (76 launches a step against native's +40 and one graph, 21 pool allocations and 21 small copies a step). + +**NVIDIA H200** (DigitalOcean, atl1, driver 580.196, CUDA 13.1, 24 host cores) at +`67491bf9`: native's CUDA build (HOPPER90, 8 minutes) against `julia` (CUDA.jl on the +local toolkit), `--device`, 2 % windows; the Julia GPU tests passed there (33 selected). + +| case | native / s | julia / s | ratio | julia32 df32 / s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.038 | 0.071 | 1.85 | 0.087 | 2.04 | +| `argon_blueshift` | 0.070 | 0.145 | 2.10 | 0.136 | 1.93 | +| `h2_raman_6ps` | 0.223 | 0.313 | 1.39 | 0.373 | 1.67 | +| `ctc_reduced` | 0.070 | 0.081 | 1.16 | 0.101 | 1.46 | +| `radial_filament_256` | 0.061 | 0.106 | 1.73 | 0.100 | 1.65 | +| `kerr_beam_192` | 0.188 | 0.428 | 2.26 | 0.355 | 1.82 | +| `line` | 0.061 | 0.103 | 1.62 | 0.093 | 1.49 | + +Geometric means 1.69 (binary64; 2.39 at `a6722029`) and 1.71 (binary32 df32, 2 rounds). +Julia's times are the A40's or a little better (`rdw` 0.071 against 0.074): it is +host-bound there, where native's binary64 kernels take the H200's full rate (`h2_raman_6ps` +0.223 s against the A40's 1.04) and its sources replay as CUDA graphs. Binary32 gains +nothing on a full-rate card. + +**NVIDIA A40, tiled transposes and kept reduction workspaces** (jl23, `8765b584` +against `67491bf9`'s engine, 3 rounds): binary64 `kerr_beam_192` 0.95, `rdw` 0.97, +`argon_blueshift` 1.02, `line` 1.05 (range 0.75–2.18), geometric mean 1.00; binary32 +df32 `kerr_beam_192` 0.92, `line` 0.95, 0.96 over the four. Fields identical. + +**Where the A40's host time goes** (`rdw`, 59 steps, `SOLPROP_JULIA_TIMING=host`, which +times sections without synchronising): the march's trials hold about half the window +(a trial about 0.43 ms of host: the plasma's passes 0.1, their projections' four cuBLAS +calls 0.07, synthesis and projection 0.05), and the statistics of 12 saved planes about +a third (2 ms a plane: the Poynting set 0.7, the population scan 0.4). A source launched +pass by pass against its captured CUDA graph's replay (`scripts/graph_probe.py`): `rdw` +962 against 386 us a source (host 415 against 4), `argon_blueshift` 848 against 267, +`h2_raman_6ps` 1201 against 663, results identical. + +**NVIDIA A40, source evaluations as CUDA graphs** (`graph_source!`; A/Bs against the +same tree with `SOLPROP_JULIA_GRAPH=0`, 3 rounds, fields identical). A source's passes, +kernels, cuFFT and cuBLAS alike, are captured once their buffers and host values have +repeated three times, then replayed. The stage's scalars (the Kerr factor and the plasma +channels' densities and preionisations) are read from one device vector, uploaded when +they change, so a gradient's every stage replays one graph; the taper (a product's +alpha) is still a captured value. Binary64 0.95 (`argon_blueshift` 0.86, `ctc_reduced` +and `h2_raman_6ps` 0.95, `rdw` 0.99, free space 0.96 and 0.99); binary32 df32 0.89 +(`argon_blueshift` 0.67, `ctc_reduced` 0.77, `h2_raman_6ps` 0.82, `rdw` 0.88; +`kerr_beam_192` 1.04, `line` 1.19 with a range of 0.68–1.45). With the scalars as +captured values instead (a gradient's keys never repeat) `rdw` was 1.21. Nsight on +`argon_blueshift` (binary64): the window 0.197 s against 0.155, the same 85 ms of +kernels, the launch API from 34 to 12 ms; `ctc_reduced` is now mostly the device's +(87 of 133 ms kernels, 40 ms of waiting in `cuEventSynchronize`). + +**A whole Adams trial as one graph** (predictor, source and corrector, the step and the +tables read from device memory; tried and reverted): 1.60 in binary64 (`rdw` 3.5, +radial 2.2, `argon_blueshift` 2.0). The predictor's and corrector's kernels take the +order and the number of defect rows as values, which the variable-order controller +changes from trial to trial, so a run captured and instantiated a graph for each +combination it met. Order-independent kernels (the order and rows read from the device, +loops to the largest) would be needed first. + +**NVIDIA A40 against native at `51a153de`** (source graphs; jl31, 3 rounds binary64, 2 +binary32): + +| case | native / s | julia / s | ratio | julia32 df32 / s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.053 | 0.073 | 1.38 | 0.066 | 1.22 | +| `argon_blueshift` | 0.117 | 0.143 | 1.23 | 0.100 | 0.86 | +| `h2_raman_6ps` | 1.041 | 0.624 | 0.60 | 0.258 | 0.25 | +| `ctc_reduced` | 0.206 | 0.124 | 0.60 | 0.079 | 0.38 | +| `radial_filament_256` | 0.167 | 0.240 | 1.42 | 0.127 | 0.73 | +| `kerr_beam_192` | 0.187 | 0.432 | 2.44 | 0.468 | 2.49 | +| `line` | 0.095 | 0.120 | 1.28 | 0.103 | 1.05 | + +Geometric means 1.15 (binary64) and 0.79 (binary32 df32). `kerr_beam_192`'s window is +one RK4IP step on a 226 MB state: of its 0.42 s, the copy of the saved plane's field to +the host took 0.29 (the step's device work waited for, then three host passes and two +allocations), and the initial load 0.065. + +**NVIDIA A40, direct state copies** (a state above 16 MB copied from the device straight +into the reader's buffer, and a binary64 load copied straight up; a smaller one held +once a state as before; jl33/jl34 against `51a153de`, 3 rounds): `kerr_beam_192` 0.56 +(binary64, 0.416 to 0.232 s) and 0.60 (binary32 df32), `rdw` 1.01 and 1.01, radial 1.09 +and 0.90 (ranges 1.08–1.25 and 0.72–1.15), `line` 0.98 and 1.02. Against native's 0.187 +s, `kerr_beam_192` is about 1.24 in binary64. A first version that also changed the small +states' copy to a broadcast cost `rdw` 1.12: the new method compiled inside the timed +window (the compile trace lists the old operations). + +**An order-independent Adams trial graph** (tried and reverted): the predictor and +corrector compiled at the largest width, reading the trial's order, width and defect +rows from device memory, so that one graph serves a run (`rdw` captured once and +replayed every trial; launches a step 14.3 to 11.2, `argon_blueshift` 7.5 to 4.4). +Against `e3b07264` (jl35, 3 rounds): binary64 1.03 (`rdw` 1.45, `h2_raman_6ps` 1.09, +`argon_blueshift` 0.97, `ctc_reduced` 1.00), binary32 df32 1.10 (`rdw` 1.70). The +predictor's phi functions formed to the largest width cost more than the three +launches saved, and the host time left is not in those launches. + +**Where a step's time goes, native against Julia** (A40, binary64, Nsight with graph +nodes, `scripts/step_timeline.py`: each step between two graph launches, median over the +window). `argon_blueshift`: native 466 us a step, the device busy 377, idle 88, 5 +launches and 1 copy; Julia at `e3b07264` 539 us, busy 375, idle 164, 8 launches and 3 +copies. `rdw`: native 629 (busy 561, idle 68), Julia 817 (busy 636, idle 180). The +device's work is the same; the difference is idle time. Julia's largest gap was after +the corrector's reduction (about 50 us a step: AK's reduction finished its last stage on +the host); then the host's preparation after the norm's readback (30 us against native's +20), the source graph's launch (`cuGraphLaunch` about 56 us of host), and the saved +planes (about 1.8 ms of idle device a plane against 1.25; in Python's profile the time +is inside the Julia calls, each with its own wait, not in numpy). + +**NVIDIA A40, fused device reductions** (`fused_reduce!`: each element formed inside the +reduction's first pass, the blocks' partials by a second, the one value read back; +`reduce_each` and `sum_device!` through it; jl37 against `e3b07264`, 3 rounds): binary64 +0.96 (`rdw` 0.99, `argon_blueshift` 0.99, `ctc_reduced` 0.99, `h2_raman_6ps` 0.98, +radial 1.05; `line` and `kerr_beam_192` noisy). In Nsight `argon_blueshift`'s step went +from 539 to 509 us, its idle from 164 to 136 (native 88). + +**AMD Instinct MI300X** (DigitalOcean, atl1, a VF, ROCm 10.0 in the image, gfx942, 20 +host cores) at `1b17fc75`: native's HIP build (4 minutes) against `julia` on AMDGPU.jl, +`--device`, 2 % windows; the Julia GPU tests passed there (33 selected). Julia on ROCm +has the inlined bodies, the fused reductions and the direct copies, but not the graphs +(CUDA's only so far). + +| case | native / s | julia / s | ratio | julia32 df32 / s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.036 | 0.058 | 1.62 | 0.111 | 3.08 | +| `argon_blueshift` | 0.063 | 0.106 | 1.68 | 0.101 | 1.56 | +| `h2_raman_6ps` | 0.241 | 0.263 | 1.09 | 0.254 | 1.06 | +| `ctc_reduced` | 0.068 | 0.063 | 0.92 | 0.083 | 1.20 | +| `radial_filament_256` | 0.054 | 0.095 | 1.75 | 0.085 | 1.58 | +| `kerr_beam_192` | 0.117 | 0.104 | 0.89 | 0.141 | 1.26 | +| `line` | 0.062 | 0.080 | 1.30 | 0.080 | 1.29 | + +Geometric means 1.28 (binary64; the MI325X's was 2.48 at `a6722029`) and 1.48 (binary32 +df32, 2 rounds). On a card with binary64 at full rate the double-float wide type costs +more than binary64 itself (`rdw` 0.111 s against 0.058), so binary32 with df32 belongs to +cards without fast binary64 (an A40, an Apple GPU). + +**Fused device reductions, reverted.** Binary32 df32 against `e3b07264` (jl37, jl41): +1.15 over the seven cases in jl37, and in a focused rerun `ctc_reduced` 1.11 (1.06–1.14), +`argon_blueshift` 0.98, `h2_raman_6ps` 0.96. A hybrid (heavy bodies' values into scratch +first, then the two-pass device reduction; light ones fused) measured binary64 1.01 and +binary32 0.98, `ctc_reduced` still 1.20 in binary32 (jl42). The kernel timer, without +graphs, shows no slower kernel on `ctc_reduced` (0.149 against 0.144 s), so the loss is in +how the reductions sit beside the replayed graphs, not found. Neither version measures +better over whole windows, so AK's reductions (with kept workspaces) stay; the per-trial +host staging kept from `1b17fc75` is unchanged. + +**A saved plane on the A40** (`rdw`, binary64, one plane's window from the Nsight trace, +`scripts/plane_calls.py` on DMOG): a 3.7 ms window, of which the step itself is about +0.65 ms and the observation's device work a few microseconds a kernel. The rest is the +host: about 1.1 ms in stretches with no CUDA call at all (170, 360, 470 and 140 us) +between the adapter's Python-to-Julia calls (the state copy, the Poynting set, the +weight's rebinding, the populations, the boundary energies), and the calls' own small +copies and waits; CUDA.jl uploads each GEMM's two scalars separately (an allocation +from the pool and an 8-byte copy each). One Julia call a plane, returning everything the +plane's statistics need, is the change this points at. + +**NVIDIA H100** (DigitalOcean, tor1, CUDA 13.1, 20 host cores) at `6f686ea4` (source +graphs, direct copies; native's build HOPPER90), binary64, 3 rounds: native against +Julia 1.25 (`kerr_beam_192` 0.66, `ctc_reduced` 0.98, `h2_raman_6ps` 1.13, +`argon_blueshift` 1.42, `rdw` 1.59, radial 1.60, `line` 1.77; fields within 4e-14). The +H200 at `67491bf9`, before the graphs and the copy fix, was 1.69. diff --git a/docs/dev/testing.md b/docs/dev/testing.md index c70b32932..1b701b04a 100644 --- a/docs/dev/testing.md +++ b/docs/dev/testing.md @@ -102,6 +102,14 @@ MLX's CPU device, and basedpyright on `mlx_gpu`. It is in [#85](https://github.com/LupoLab/solprop/issues/85) with the rest of the backend's path to full support ([backends.md](backends.md) §4a). +### The `julia` omission + +The experimental `julia` backend's package, `solprop/backends/julia`, is left out of the +coverage lane too (`omit` in `coverage-cpu.ini`). Its tests, +`tests/backends/test_julia.py`, skip unless `solprop[julia]` is installed and +`julia/bootstrap.py` has prepared a Julia runtime, which no CI lane does: the backend is +an experiment, not a release feature (`julia/STATUS.md`). + Hypothesis properties use the `solprop` profile loaded by `tests/conftest.py`. Their example count bounds the work; the per-example wall-clock deadline is disabled because imports, JIT compilation and contention on shared machines can exceed it diff --git a/docs/guide/performance/backends.md b/docs/guide/performance/backends.md index 4e33e28d2..60ec61b2b 100644 --- a/docs/guide/performance/backends.md +++ b/docs/guide/performance/backends.md @@ -13,6 +13,7 @@ native backend, which `"auto"` selects; `mlx` and `numpy_ref` are for the cases |---|---|---| | `native` | the [native backend](native.md), the solprop-native distribution built from the repository's `native/` directory and a required dependency of solprop: OpenMP, FFTW and a vendor BLAS on a CPU, or CUDA/HIP on a GPU | **the one to use**: what `"auto"` selects | | `mlx` | the Apple-silicon GPU through Apple's MLX, in **single precision only** ([single precision](single-precision.md)); the `mlx` extra, macOS on Apple silicon; **experimental** in this release | `precision="single"` capillary and fibre runs on a Mac, where it is the `"auto"` choice; it refuses `precision="double"` | +| `julia` | an **experiment** on this branch only: one Julia source for a CPU or an NVIDIA GPU, binary64 or binary32 ([the Julia experiment](julia.md)); the `julia` extra and a prepared Julia runtime | measuring what a compact single-source engine reaches; not for results | | `numpy_ref` | plain NumPy, the numerical **reference**: every other backend is tested against it. It is unthreaded, and roughly 6 to 40 times slower than threaded native | checking a result, and [the features native does not run](#features-that-run-on-the-reference-backend). Also problems a GPU build refuses or runs slowly, in a process that has only that build | ## Which backend a run uses diff --git a/docs/guide/performance/index.md b/docs/guide/performance/index.md index 68df1c223..c7ba05807 100644 --- a/docs/guide/performance/index.md +++ b/docs/guide/performance/index.md @@ -22,4 +22,5 @@ resources progress tuning single-precision +julia ``` diff --git a/docs/guide/performance/julia.md b/docs/guide/performance/julia.md new file mode 100644 index 000000000..1be3b1db5 --- /dev/null +++ b/docs/guide/performance/julia.md @@ -0,0 +1,69 @@ +# The Julia experiment + +`backend="julia"` is an experiment on this branch, not a supported backend: it asks how +fast one compact Julia source can run solprop's routes on a CPU and on NVIDIA, AMD and +Apple GPUs, in binary64 or binary32. Use the [native backend](native.md) for results. The design, +the measurements and what is left are in the branch's `julia/STATUS.md`. + +## What it runs + +The translated problem is the same one every backend executes ([choosing a +backend](backends.md)); the julia backend steps it behind the same seam as native, and +refuses by name what it does not run. + +| | runs | refuses | +|---|---|---| +| routes | resolved and mode-averaged capillaries (constant radius, separable longitudinal profiles), radial, Cartesian and line free space | planar and general modal guides, tapers, coupled flows | +| responses | Kerr (with THG), one field-grid plasma channel, one constant Raman term (modal) | envelope plasma, several channels or Raman terms, varying Raman, dispersive Kerr, TDSE, noise | +| steppers | DOPRI5 with FSAL, the exponential Adams march (not Cartesian), RK4IP (Cartesian) | the interaction Adams formulation, the carrier frame, interpolated planes | +| execution | CPU threads; an NVIDIA GPU (`SOLPROP_JULIA_DEVICE=cuda`), an AMD GPU (`rocm`) or an Apple GPU (`metal`, binary32 only); `precision="double"` or `"single"` | vector polarisation, batches; binary64 on an Apple GPU | + +## Trying it + +From a checkout of the branch: + +```sh +uv sync --extra julia +uv run --no-sync python julia/bootstrap.py # add --cuda, --rocm or --metal for a GPU +SOLPROP_JULIA_THREADS=16 uv run --no-sync python my_run.py # with backend="julia" +``` + +The bootstrap downloads Julia 1.13.3 (checksummed) unless `SOLPROP_JULIA_EXE` names one, +and instantiates the committed manifest. A run's first propagation pays nothing for +Julia's compilation: the engine compiles and runs each of its paths once when it is +constructed, which takes seconds. `julia/README.md` lists the environment variables. + +## How it is built + +One source for every device and precision. Each state-sized operation is a scalar +function launched over the state by a small device layer: on a CPU, Polyester tasks +running contiguous SIMD loops; on a GPU, a KernelAbstractions kernel a sample a thread. +FFTs are AbstractFFTs plans (FFTW or cuFFT) and contractions `mul!` (BLAS or cuBLAS). +On a CPU one pool runs everything, the transforms as blocks of single-threaded plans and +the products as blocks of rows, because the libraries' own threads beside the pool's +made a run slower on four threads than on one. The plasma's columns use branch-free +vectorised `exp` and `log` within one ulp, and the exponential Adams march itself runs +in the engine, as native's compiled march does. In binary32 the state is held as +`a / s` for SEP 33's power-of-two scale `s`, and the operator stays binary64, so +propagators and the longitudinal root are formed in binary64 and rounded once. Where the +device has no binary64 (an Apple GPU), or on request (`SOLPROP_JULIA_WIDE=df32`), they +are formed in double-float instead, a value as two binary32s (about 48 bits), and still +rounded once. On macOS the products use Apple's Accelerate. + +## How fast it is + +Indicative only: the seven focus cases, measured with `python -m benchmarks ab` +against native on the same machine, as julia's time over native's (below one, julia is +faster). The branch's ledger +([benchmarks](../../dev/benchmarks.md#julia-backend-experiment)) has the numbers, the +machines and the commits. + +| machine | geometric mean | notes | +|---|---:|---| +| Apple M5 Max CPU, 6 threads | 0.82 | whole runs; 0.68 to 1.02 by case | +| Intel Xeon Gold 6240, 16 threads | 1.13 | 2 % windows; 0.78 to 1.26 | +| NVIDIA A40, binary64 | 1.97 | host-bound | +| NVIDIA H200 / AMD MI325X, binary64 | 2.39 / 2.48 | host-bound; before later fixes | +| Apple M5 Max GPU, binary32 | 1.95 against native's 6 CPU threads; 1.25 against `mlx` | the Cartesian beam 0.33 and 0.71 | + +On GPUs what is left is the host: the launches, copies and waits of each step. diff --git a/hatch_build.py b/hatch_build.py index 41ae6715a..44d6cdc55 100644 --- a/hatch_build.py +++ b/hatch_build.py @@ -72,3 +72,6 @@ def update(self, metadata: dict[str, Any]) -> None: # raised only with the GPU lane and the arithmetic probes run (Q9). apple_silicon = 'sys_platform == "darwin" and platform_machine == "arm64"' extras["mlx"] = [f"mlx>=0.32.4,<0.33; {apple_silicon}"] + # The Julia backend experiment, through JuliaCall; its Julia packages are + # pinned by julia/Manifest.toml. + extras["julia"] = ["juliacall==0.9.37"] diff --git a/julia/METAL_HANDOFF.md b/julia/METAL_HANDOFF.md new file mode 100644 index 000000000..02f0368d9 --- /dev/null +++ b/julia/METAL_HANDOFF.md @@ -0,0 +1,164 @@ +# Handoff: the Julia backend on a Mac (CPU comparison, then Metal) + +> **Done, 2026-11-07.** Both steps are complete: the CPU comparison (Julia 0.82 over +> native's whole runs on the M5 Max) and the Metal extension, with double-float in place +> of binary64 (`src/dfloat.jl`). The results, the floating-point experiments and an +> assessment of Julia as a first-class backend are in [STATUS.md](STATUS.md); the rows +> are in the ledger. What follows is the note as it was written. + +For the agent picking this up on the maintainer's Mac (Apple M5 Max). The work is draft +PR #559, branch `feature/julia-backend-experiment` (do not merge; heads `[skip ci]`). +Read `AGENTS.md`, then [README.md](README.md) (setup, variables, files) and +[STATUS.md](STATUS.md) (what the engine is, what made it fast, the measurements, what is +left). The ledger rows are in `docs/dev/benchmarks.md`, "Julia backend experiment". +Native ideas found on the way are #560. + +## Where it stands + +`backend="julia"` steps solprop's translated problem behind the same `StepDriver` seam +as native. The engine is one Julia source (`julia/src`), run three ways: +- on a CPU, by Polyester tasks; +- on NVIDIA GPUs, through CUDA.jl (`ext/SolpropJuliaCUDAExt.jl`, environment `julia/cuda`); +- on AMD GPUs, through AMDGPU.jl (`ext/SolpropJuliaAMDGPUExt.jl`, environment `julia/rocm`). + +It runs in binary64 or binary32 (SEP 33). The exponential Adams march itself runs in the +engine (`src/march.jl`). Its windows match native's steps, and match its fields to +rounding. + +Julia's window time over native's, at commit `a6722029` (below 1, Julia is faster): + +| Machine | Geometric mean | Range | Notes | +|---|---:|---|---| +| Intel Xeon Gold 6240, 16 threads | 1.13 | 0.78 to 1.26 | faster on `line`, `ctc_reduced`, `h2_raman_6ps` | +| Same, one thread | | 0.97 to 1.56 | | +| NVIDIA A40, binary64 | 1.97 | | | + +The NVIDIA H200 (2.39) and the AMD Instinct MI325X (2.48) were measured before the fix +for compilation inside the first window, so their radial and free-space rows overstate +the gap. + +## Step 1: a light CPU comparison with native on the M5 Max + +PR #10's prototype was last measured on this Mac. The engine has since been rewritten, +so this is the first measurement of the current one there. + +1. Set up, from a checkout of the branch: + + ```sh + uv sync --extra julia # native builds as AGENTS.md says + juliaup add 1.13 # or let the bootstrap download the release + export SOLPROP_JULIA_EXE=$(julia +1.13 -e 'print(joinpath(Sys.BINDIR, "julia"))') + uv run --no-sync python julia/bootstrap.py + ``` + + The first package build replays `src/precompile_trace.jl` (about a minute; see + "Start latency" below). +2. Run the tests: `uv run --no-sync pytest tests/backends/test_julia.py -n 4`. They + should all pass, CPU only; the GPU-marked ones are deselected. +3. Run the comparison. Use the performance cores only; macOS cannot pin threads, so + find their count with `sysctl hw.perflevel0.physicalcpu`: + + ```sh + P=$(sysctl -n hw.perflevel0.physicalcpu) + uv run --no-sync python -m benchmarks ab --baseline-backend native --candidate-backend julia \ + --baseline-python .venv/bin/python --case rdw --case argon_blueshift --case h2_raman_6ps \ + --case ctc_reduced --case radial_filament_256 --case line --case kerr_beam_192 \ + --stepper default --noise none --threads 1,$P --length 0.02 --rounds 3 --repeats 1 \ + --out + ``` + + Record the commit, the machine and the rows in the ledger's Julia section. +4. Things to watch on Apple silicon: + - **Efficiency cores.** Polyester's tasks are static: a task on an efficiency core + holds back every pass, so more threads than performance cores may be slower. + - **BLAS.** Julia uses OpenBLAS through libblastrampoline. Accelerate (AppleAccelerate.jl) + may be faster for the GEMMs; the prototype had an Accelerate option. + - **SIMD.** FFTW and `src/vmath.jl` (branch-free `exp`/`log`, plain Julia) vectorise + with NEON's two binary64 lanes, not AVX-512's eight; the plasma's gains may be smaller. + - **Compilation in the window.** `test_julia_first_window_compiles_nothing` holds the + first timed window to under 50 ms of compilation; check it passes here. + +## Step 2: a Metal extension + +Metal.jl 1.10 has AbstractFFTs plans (on MPSGraph), `mul!` through MPS, and a +KernelAbstractions backend; AcceleratedKernels supports it. So the device layer, kernels, +reductions and scans should carry over, as they did for AMD tonight. That took about an +hour from writing the extension to all tests passing; see commit "an AMDGPU extension +and its environment" for the pattern: +- the extension file; +- the environment `julia//Project.toml`, resolved into its own `Manifest.toml`; +- the `[weakdeps]` and `[extensions]` entries in `julia/Project.toml`; +- `_GPU_PACKAGES` and the device check in `src/solprop/backends/julia/_runtime.py`; +- the source digest's file list in the same module; +- `bootstrap.py --`; +- the benchmark worker keeping the named device under `--device`. + +The one real problem is binary64. **Apple GPUs have none**, and the engine deliberately +keeps these in binary64 on the device, even in binary32 runs (SEP 33, 4.1 item 3): + +| Where | What | +|---|---| +| `src/modal.jl` (`linear=upload(..., ComplexF64)`) | the linear operator | +| `src/dopri.jl` (`propagators!`) | the propagators' exponents, `exp(h L)` | +| `src/adams.jl` (`adams_trial_width!`: `x = ComplexF64(step * linear[f, m])`, `phi_values`) | the Adams phi functions | +| `src/stages.jl` (`delta_device`, `path.phi`) | a varying operator's stage increments | +| `src/free.jl` (the `op` tables, `free_element`, `free_propagators!`) | the free-space operator and its longitudinal root | + +Two ways round it: + +1. **Form those on the CPU in binary64 and hand the device binary32 results.** + - Unified memory makes the handoff cheap, and Polyester threads on the host can form + them. + - The phi functions depend on `h L` per element and are formed every trial: about + 100 ns an element, so rdw's 10 k elements cost about 1 ms on one core. + - DOPRI's propagators change only with `dz`. + - It suits the capillary routes (rdw, argon, ctc, h2). Cartesian recomputes its root + per element and stage, which is the costly case. +2. **Double-float arithmetic** (a binary64 value as a pair of binary32s) in those + kernels, as the mlx backend's Adams flow does (#543). It is general but more work. + +Suggested order: +1. Admit `precision="single"` only on Metal; refuse binary64 by name. +2. Get rdw (modal, Adams) running with option 1, then argon, then radial. +3. Hold off on free space. +4. Use `--fft-size pow2`: MLX's GPU FFTs fell back to Bluestein above 4096 points for + other sizes (#543). Whether MPSGraph does the same is unchecked. + +Then compare against the mlx backend on the same windows: Julia's single source against +hand-written MLX. + +Things to check early on Metal: +- **In-place and batched plans.** Whether Metal.jl's FFT plans support in-place + `plan_bfft!`/`plan_fft!` and transforms along dimension 1 of a matrix. The engine uses + both; `src/observe.jl` and `src/responses.jl` have the in-place ones. +- **Real views.** `reinterpret` of an `MtlArray` (`real_rows` in `src/launch.jl`, for + complex-by-real products). +- **Atomics.** Binary32 atomics in local memory (`bucket_kernel!` in `src/observe.jl`). +- **Scalar indexing.** `Metal.allowscalar(false)`, as the other extensions set. + +## What this branch learned (applies on any device) + +- **Kernel bodies capture values, not types.** A closure that captures `Type{T}` or a + `Core.Box` is refused on a GPU. `SOLPROP_JULIA_CHECK=1`, which the tests set, refuses + it on a CPU too. Capture `zero(T)` and similar as values. +- **Nothing may compile inside a timed window.** The benchmark worker's warm-up runs + without a boundary monitor, so construction must warm every bridge entry with the + argument types a run passes. A read-only NumPy array is a different bridge type from a + writable one. Check with juliacall's `PYTHON_JULIACALL_TRACE_COMPILE=` (with + `PYTHON_JULIACALL_TRACE_COMPILE_TIMING=yes`) around a timed run. +- **Start latency.** + - The first engine in a process compiles its configuration's specialisations: 34 to + 64 s, cut to 11 to 14 s by replaying `src/precompile_trace.jl` when the package + builds. + - Regenerate the trace after large changes: run each case with the trace variable set, + collect the `precompile(` lines, `sort -u`. + - On a new device, add its specialisations the same way. + - A PackageCompiler system image would remove the rest; it has not been tried. +- **GPU windows are host-bound** on GPUs with full-rate arithmetic. Count launches and + allocations per trial before tuning kernels; the scratch cache in `c.scratch` + (`scratch` in `src/launch.jl`) exists for this. +- **Benchmark hygiene.** + - Nothing else on the machine while an A/B runs: tonight's own test runs contaminated + one. + - Measured FFT plans differ between processes; for bit-for-bit comparisons set + `SOLPROP_FFTW_PLAN=estimate`. diff --git a/julia/Manifest.toml b/julia/Manifest.toml new file mode 100644 index 000000000..c8f6df2bd --- /dev/null +++ b/julia/Manifest.toml @@ -0,0 +1,950 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "4fa6779d3f296b1c200044814053d5b7a829e045" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.AcceleratedKernels]] +deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] +git-tree-sha1 = "ac481710a9eee43b1d8dbd1e26a49a19de71475a" +registries = "General" +uuid = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +version = "0.5.11" + + [deps.AcceleratedKernels.extensions] + CUDACoreExt = "CUDACore" + MetalExt = "Metal" + OpenCLExt = "OpenCL" + oneAPIExt = "oneAPI" + + [deps.AcceleratedKernels.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "eec8a0ad4e4b673afba213931504c360fffb8f97" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.8.0" + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + + [deps.Adapt.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +registries = "General" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "0aa371c875e24cf773c87b2f50ab03e4545748af" +registries = "General" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.7.0" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +registries = "General" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerCaching]] +deps = ["LMDB", "SHA", "Scratch"] +git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" +registries = "General" +uuid = "9db33cc3-5358-4881-8759-fa4194144afd" +version = "0.5.3" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CondaPkg]] +deps = ["FileWatching", "JSON", "Markdown", "MicroMamba", "Pkg", "Preferences", "Scratch", "TOML", "pixi_jll"] +git-tree-sha1 = "5105aafa8fedef75ad7f44d7dbf85a1b7196e406" +registries = "General" +uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +version = "0.2.38" + +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +registries = "General" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +registries = "General" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "f60436514e6d73f8ee069ae4ee0ff038fe96b69d" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.2" + +[[deps.GPUCompiler]] +deps = ["CompilerCaching", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "REPL", "ScopedValues", "TOML", "Tracy", "UUIDs", "tree_sitter_gcn_jll", "tree_sitter_llvm_jll", "tree_sitter_ptx_jll", "tree_sitter_spirv_jll"] +git-tree-sha1 = "65175d8064f99fc7a27cc9b69bed573b35ee080e" +registries = "General" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "2.21.0" + + [deps.GPUCompiler.extensions] + CthulhuExt = "Cthulhu" + HighlightsExt = "Highlights" + + [deps.GPUCompiler.weakdeps] + AMDGPU_LLVM_Backend_jll = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" + Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f" + Highlights = "eafb193a-b7ab-5a9e-9068-77385905fa72" + LLVMDowngrader_jll = "f52de702-fb25-5922-94ba-81dd59b07444" + NVPTX_LLVM_Backend_jll = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" + SPIRV_LLVM_Backend_jll = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" + SPIRV_LLVM_Translator_jll = "4a5d46fc-d8cf-5151-a261-86b458210efb" + +[[deps.GPUToolbox]] +git-tree-sha1 = "a380d7a5bf9be3fb1e85344c683bab446f4861c0" +registries = "General" +uuid = "096a3bc2-3ced-46d0-87f4-dd12716f4bfc" +version = "3.5.1" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +registries = "General" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "06d90f699285d055e34f0b014636a75a17ff2252" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.13.4" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + JSONSerializationExt = ["Serialization"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "MacroTools", "PrecompileTools", "Printf", "Random", "Random123", "RandomNumbers", "SPIRVIntrinsics", "SPIRV_LLVM_Backend_jll", "SPIRV_Tools_jll", "StaticArraysCore", "UnsafeAtomics", "pocl_standalone_jll"] +git-tree-sha1 = "0b9e978d21df1aa3ead81c89a2bdf3c6f063a39c" +registries = "General" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.10.5" + + [deps.KernelAbstractions.extensions] + AMDGPUExt = "AMDGPU" + LinearAlgebraExt = "LinearAlgebra" + MetalExt = "Metal" + SparseArraysExt = "SparseArrays" + StaticArraysExt = "StaticArrays" + oneAPIExt = "oneAPI" + + [deps.KernelAbstractions.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.KernelInterface]] +git-tree-sha1 = "62300ced3fd046f4694e8dbf0e2fbc2bed84f371" +registries = "General" +uuid = "4ee993da-d684-4d17-a7dd-4e58e78d92bf" +version = "0.4.5" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "PrecompileTools", "Preferences", "Printf", "ScopedValues", "Unicode"] +git-tree-sha1 = "41c2ce7ec5a14c89b93dc6a5853bf2a91d7a8583" +registries = "General" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "10.4.3" + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + + [deps.LLVM.weakdeps] + BFloat16s = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "39def0b4521e0ef2bf26960d8965729f496bb4ec" +registries = "General" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.56+0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LMDB]] +deps = ["CEnum", "LMDB_jll"] +git-tree-sha1 = "84e5cba87693714bfd67f589a91f24a996ff3e69" +registries = "General" +uuid = "11f193de-5e89-5f17-923a-7d207d56daf9" +version = "3.0.1" + +[[deps.LMDB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "196c962b4d66b978b9be1e15e4e1d53441d5f028" +registries = "General" +uuid = "6206cf0b-f360-5984-af49-5437264c140e" +version = "1.0.3+0" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +registries = "General" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MicroMamba]] +deps = ["Pkg", "Scratch", "micromamba_jll"] +git-tree-sha1 = "535656ce55266bfed0575cd051acc4f36dc869a0" +registries = "General" +uuid = "0b3b1443-0f03-428d-bdfb-f27f9c1191ea" +version = "0.1.15" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "b079a6affebde167dad8ffe0d670b53917fbcb68" +registries = "General" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "2.0.3" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools"] +git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "3.0.6" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PythonCall]] +deps = ["CondaPkg", "Dates", "Libdl", "MacroTools", "Markdown", "Preferences", "Serialization", "Tables", "UnsafePointers"] +git-tree-sha1 = "00d3a883b716a8482da76d08dae1f6084bbfeb23" +registries = "General" +uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +version = "0.9.37" + + [deps.PythonCall.extensions] + CategoricalArraysExt = "CategoricalArrays" + PyCallExt = "PyCall" + + [deps.PythonCall.weakdeps] + CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +registries = "General" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +registries = "General" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEF_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" +registries = "General" +uuid = "63e82ce6-3d80-5af4-a84c-484b71ab98bb" +version = "3.9.0+2" + +[[deps.SPIRVIntrinsics]] +deps = ["GPUToolbox", "LLVM", "UnsafeAtomics"] +git-tree-sha1 = "2ee2b6f667d53d1f03079ce7179f7de7ef5058b7" +registries = "General" +uuid = "71d1d633-e7e8-4a92-83a1-de8814b09ba8" +version = "1.6.0" + + [deps.SPIRVIntrinsics.extensions] + SPIRVIntrinsicsSIMDExt = "SIMD" + SPIRVIntrinsicsSIMDSpecialFunctionsExt = ["SIMD", "SpecialFunctions"] + SPIRVIntrinsicsSpecialFunctionsExt = "SpecialFunctions" + + [deps.SPIRVIntrinsics.weakdeps] + GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55" + SIMD = "fdea26ae-647d-5447-a871-4b548cad5224" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SPIRV_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "6aaddfdf3040d02a5b3e10c6cd0e4e1dce27f23c" +registries = "General" +uuid = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" +version = "23.1.4+1" + +[[deps.SPIRV_Tools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "783c358eff59056d7e703a644f5179270c43226a" +registries = "General" +uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" +version = "2025.4.0+0" + +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SolpropJulia]] +deps = ["AcceleratedKernels", "Atomix", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] +path = "." +uuid = "bc9db228-6fd1-46b1-b175-748485922872" +version = "0.0.0" + + [deps.SolpropJulia.extensions] + SolpropJuliaAMDGPUExt = "AMDGPU" + SolpropJuliaCUDAExt = "CUDA" + SolpropJuliaMetalExt = "Metal" + + [deps.SolpropJulia.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" +registries = "General" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.12.0" + + [deps.StructUtils.extensions] + StructUtilsDBInterfaceExt = ["DBInterface", "Tables"] + StructUtilsDataFramesExt = ["DataFrames"] + StructUtilsLazilyInitializedFieldsExt = ["LazilyInitializedFields"] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazilyInitializedFields = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +registries = "General" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "a94d9bdda1b7bed0046cea645639ab3f62196fac" +registries = "General" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.14.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +registries = "General" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +deps = ["LLVM"] +git-tree-sha1 = "74ac5e0e702972da953ffc981094617070be582d" +registries = "General" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.4.0" +weakdeps = ["GPUCompiler"] + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsGPUCompilerExt = "GPUCompiler" + +[[deps.UnsafePointers]] +git-tree-sha1 = "c81331b3b2e60a982be57c046ec91f599ede674a" +registries = "General" +uuid = "e17b2a0c-0bdf-430a-bd0c-3a23cae4ff39" +version = "1.0.0" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.micromamba_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "717df6f6892af4ee13279a73aa58474e58a88667" +registries = "General" +uuid = "f8abcde7-e9b7-5caa-b8af-a437887ae8e4" +version = "2.3.1+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + +[[deps.pixi_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "56c56fede8f01e1be7e2fdf1eb911487640619a0" +registries = "General" +uuid = "4d7b5844-a134-5dcd-ac86-c8f19cd51bed" +version = "0.76.2+0" + +[[deps.pocl_standalone_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] +git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" +registries = "General" +uuid = "54f56a70-6062-5590-a942-1226658f6c83" +version = "7.2.3+7" + +[[deps.tree_sitter_gcn_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7aea9f731552967bda93cb7cbf6925de65bc38d5" +registries = "General" +uuid = "8b5cbfcf-8811-596e-8e87-0e51e05ee4b2" +version = "0.1.0+0" + +[[deps.tree_sitter_llvm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2fb7d0e3a8abf532fa922766ca130bf814df1e70" +registries = "General" +uuid = "44208993-ee63-5069-9443-8e43b04a9b30" +version = "1.1.0+0" + +[[deps.tree_sitter_ptx_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e6ad264eebe3e34f03bca6b5e811d80e0f4797a2" +registries = "General" +uuid = "71e3f6e6-c059-5e7c-a2f2-d560fdad7ce5" +version = "0.1.0+0" + +[[deps.tree_sitter_spirv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7d8c03949bab84b23fe0500d89979e786d54a653" +registries = "General" +uuid = "f0e86581-c468-54df-a4de-3266e11a3c86" +version = "0.1.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/julia/Project.toml b/julia/Project.toml new file mode 100644 index 000000000..62185a601 --- /dev/null +++ b/julia/Project.toml @@ -0,0 +1,26 @@ +name = "SolpropJulia" +uuid = "bc9db228-6fd1-46b1-b175-748485922872" + +[deps] +AcceleratedKernels = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +Atomix = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" +PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" + +[weakdeps] +AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" +CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + +[extensions] +SolpropJuliaAMDGPUExt = "AMDGPU" +SolpropJuliaCUDAExt = "CUDA" +SolpropJuliaMetalExt = "Metal" + +[compat] +Atomix = "1.7.0" +Polyester = "0.7.19" +julia = "1.13" diff --git a/julia/README.md b/julia/README.md new file mode 100644 index 000000000..2b8ca42f1 --- /dev/null +++ b/julia/README.md @@ -0,0 +1,92 @@ +# The Julia backend experiment + +**An experiment, not a supported backend. Not for merge.** It asks how fast a compact, +single-source Julia engine can run solprop's routes on a CPU and on an NVIDIA GPU, +against the native backend. [STATUS.md](STATUS.md) holds the design, the measured +results and what is left; the [manual page](../docs/guide/performance/julia.md) says +how to use it. + +`backend="julia"` steps the problem solprop translates, behind the same `StepDriver` +seam as the native backend. The Python front end, the translation, the march's +controller and the output are solprop's own. The engine is the Julia package in +[`src/`](src): + +| File | What | +|---|---| +| `SolpropJulia.jl` | the engine type, construction and its warm-up, the bridge's entry points | +| `launch.jl` | the device layer: every pass a scalar body run by `each!`, `each_column!`, `reduce_each` or `rowsum!`; FFT plans and GEMMs | +| `vmath.jl` | branch-free binary64 `exp` and `log` within one ulp, for the CPU's vectorised passes | +| `modal.jl`, `free.jl` | the modal and radial routes, and Cartesian and line free space | +| `responses.jl` | Kerr, one field-plasma channel and one Raman term | +| `dopri.jl`, `rk4.jl`, `adams.jl` | the DOPRI5 trial and commit, SEP 24's RK4IP and SEP 16's exponential Adams | +| `helpers.jl` | the shared code's Chebyshev rows and Adams basis (SEP 29 section 6.6), and an Adams trial's tables | +| `stages.jl` | the longitudinal expansions' stage weights, and the stage scalars from the engine's own tables | +| `march.jl` | the exponential Adams march itself (native's SEP 39 march, transcribed), run by the engine between host events | +| `observe.jl` | what the driver reads between steps: the state, the boundary monitor's and the transverse edge's sums, the Poynting statistics' power | +| `../ext/SolpropJuliaCUDAExt.jl` | CUDA: the engine's arrays become `CuArray`s | +| `../ext/SolpropJuliaAMDGPUExt.jl` | AMD GPUs: the engine's arrays become `ROCArray`s | +| `../ext/SolpropJuliaMetalExt.jl` | Apple GPUs: the engine's arrays become `MtlArray`s; binary32 only | +| `dfloat.jl` | double-float (a value as two binary32s, about 48 bits): the operator's exponents, the propagators and the Adams flow where binary64 is absent or slow | + +## Setting up + +In a source checkout of this branch, with Julia 1.13 (or let the bootstrap download the +checksummed release): + +```sh +uv sync --extra julia +export SOLPROP_JULIA_EXE=$(julia +1.13 -e 'print(joinpath(Sys.BINDIR, "julia"))') +uv run --no-sync python julia/bootstrap.py # --cuda, --rocm or --metal for a GPU environment too +# --cuda-local: CUDA.jl on the system toolkit, beside a native build linked to it +``` + +The bootstrap instantiates `julia/Manifest.toml` into `.julia-depot/` +(`SOLPROP_JULIA_DEPOT` names another). `SOLPROP_JULIA_ROOT` names the checkout when +solprop is installed without `-e`. A run then takes `backend="julia"`: + +| Variable | Meaning | +|---|---| +| `SOLPROP_JULIA_THREADS` | the engine's threads (default 1); the benchmark harness sets it to the width | +| `SOLPROP_JULIA_DEVICE` | `cpu` (default), `cuda`, `rocm` or `metal`, which load `julia/cuda`, `julia/rocm` or `julia/metal`: CUDA.jl, AMDGPU.jl or Metal.jl resolved with the engine. `metal` runs `precision="single"` only | +| `SOLPROP_JULIA_BLAS` | `accelerate` (default on macOS: Apple's BLAS, OpenBLAS beneath) or `openblas` (default elsewhere) | +| `SOLPROP_JULIA_FTZ` | `1`: flush subnormals to zero in the engine's numerical calls (an experiment; solprop's policy forbids it, #561) | +| `SOLPROP_JULIA_WIDE` | a binary32 run's wide type for the operator's exponents, the propagators and the Adams flow: `binary64` (default) or `df32` (double-float, `src/dfloat.jl`); `metal` always uses `df32`. Binary64 runs ignore it | +| `SOLPROP_JULIA_MARCH` | `host`: the Python Adams march in place of the engine's (`src/march.jl`) | +| `SOLPROP_FFTW_PLAN` | `estimate`, `measure` (default) or `patient` | +| `SOLPROP_JULIA_TIMING` | `1`: the engine's section timers (`julia/profile.py` prints them) | +| `SOLPROP_JULIA_CHECK` | `1`: refuse any kernel body a GPU could not take, on any device (the tests set it) | +| `SOLPROP_JULIA_PLASMA` | `samples`: the GPU's per-sample plasma passes on a CPU too | + +A process holds one Julia runtime. Import nothing from `juliacall` before solprop +starts it. + +## Measuring + +The benchmark harness takes `julia` as an arm, and `julia32` for it in single precision: + +```sh +uv run --no-sync python -m benchmarks ab --baseline-backend native --candidate-backend julia \ + --baseline-python .venv/bin/python --case rdw --threads 1,16 --length 0.02 --noise none +``` + +`--device` runs both arms on the GPU that `SOLPROP_JULIA_DEVICE` names; `--device-arm +candidate` runs only that arm there, against a CPU arm. `--cooldown 30` idles before each +worker. On the Mac absolute times drift by up to 40 % over a day, so compare only +interleaved arms. An arm can take its own environment through a wrapper script given as +`--candidate-python` (for example one that sets `SOLPROP_JULIA_WIDE=df32`, or +`SOLPROP_JULIA_ROOT` to another tree's sources). + +`python julia/profile.py PLAN.json ROW...` times one plan row's complete run, warmed, +with `SOLPROP_JULIA_TIMING=1` for the sections or `SOLPROP_JULIA_PROFILE=1` for Julia's +sampling profile. `julia/bench/launch.jl` is the launch-strategy measurement the device +layer rests on. + +## Testing + +```sh +uv run --no-sync pytest tests/backends/test_julia.py -n 4 # CPU +SOLPROP_JULIA_DEVICE=metal uv run --no-sync pytest tests/backends/test_julia.py -m gpu # or cuda, rocm +``` + +Seven focus windows against `numpy_ref`: the same steps, and the field to `1e-10` in +binary64, `1e-4` against the reference's binary32 path. Julia runs bounds-checked there. diff --git a/julia/STATUS.md b/julia/STATUS.md new file mode 100644 index 000000000..efc533613 --- /dev/null +++ b/julia/STATUS.md @@ -0,0 +1,376 @@ +# The Julia experiment: status + +An experiment. Draft PR, not for merge; no CI lane runs it. This page records what the +engine is, how fast it is against native on a CPU and on an NVIDIA A40, what it does not +do, and what is left. Measurements are short windows of the benchmark cases (`python -m +benchmarks ab`, ten to two hundred steps); [the ledger](../docs/dev/benchmarks.md#julia-backend-experiment) +has the full rows. + +## What changed from PR #10 + +PR #10 was a CPU-only prototype written against kernel schema 35. This branch carries it +to current main and rewrites the engine: + +- **Main's seam.** No schema number (ADR-068): a digest of the Julia sources, the adapter + and the manifests, checked when the engine loads. `set_initial(resume=)`, the Adams + engine protocol's carrier, hold, restore, observe and snapshot size, stage scalars from + the driver's bundle cache, the general-leaf and carrier-frame refusals, SEP 21's split + collar and SEP 44's transverse edge read through the engine. +- **One source for CPU and GPU, binary64 and binary32.** Every state-sized operation is a + scalar body run by the device layer (`src/launch.jl`); arrays are `Array`s, `CuArray`s + or `ROCArray`s (the CUDA and AMDGPU package extensions) of `Float64` or `Float32`. The kernel bodies + capture only values and arrays, which `SOLPROP_JULIA_CHECK` enforces on a CPU. +- **Julia 1.13.3**, CUDA.jl 6.5, FFTW.jl, Polyester, KernelAbstractions and + AcceleratedKernels; numba is gone from the tooling, which is now solprop's own harness. + +## What made it fast + +Measured step by step on an Intel Xeon Gold 6240 (16 cores of one socket) unless said. + +| Change | Effect | +|---|---| +| Measure every FFTW plan | a threaded estimated c2r (73728 x 17) took 6.6 ms, measured 1.49 ms | +| Raman: convolve the modal products, not the node drives, where fewer (as native does) | H2 Raman window 10.8 s -> 4.7 s | +| One CPU pool: Polyester tasks for every pass, FFTs as blocks of single-threaded plans, GEMMs as blocks of rows | rdw on four threads 1.10 s -> 0.22 s; Julia's tasks cost 10 us a pass where Polyester's cost 2.2 us | +| Contiguous column loops (`each!`), not a flat index | a flat index's divide made a Kerr pass ten times slower | +| Hold host BLAS to one thread while the engine lives (as native does) | NumPy's spinning OpenBLAS made a radial window 4.3 s against 1.1 s | +| Compile and run every path, and every bridge entry, at construction | 0.6-3.5 s of JIT left the timed window | +| Monitor and edge sums, state copies, in the engine | a Cartesian window's host copies and reductions 1.7 s -> 1.1 s | +| GPU: plasma and observation populations a sample a thread, scans column-wise | A40 rdw plasma 1.23 s -> 0.04 s, argon 4.9 s -> 0.14 s | +| Native's phi-function evaluation (quarter-ulp stop, reciprocals) | radial Adams predictor 0.16 s -> 0.10 s | +| Frequency-domain synthesis where the nodes match the modes (radial) | a radial window 0.86 s -> 0.63 s on 16 threads | +| Its own helpers record (SEP 29 section 6.6), an Adams trial's tables formed in the engine | `rdw` on 16 threads 0.273 s -> 0.214 s; equal to the Python forms bit for bit | +| Stage scalars read by the engine from its own tables (SEP 39's staged tables) | `rdw` stage preparation 17 ms -> 5 ms a window | +| The Poynting statistics' transforms and the populations in the engine, without allocating | `rdw` statistics 55 ms -> 40 ms; collector pauses (13 to 83 ms) gone | +| A plasma column's live samples gathered; vectorised `exp` and `log` (`src/vmath.jl`, 1 ulp) | argon's plasma on one thread 4.7 ms -> 2.9 ms a source | +| A source's forward transforms, and the quadrature alarm's, as one pool's work | `rdw` on 16 threads: commits 12.3 ms -> 5.8 ms, the source's transforms 8.7 ms -> 3.8 ms | +| The exponential Adams march in the engine (`src/march.jl`, native's SEP 39 march transcribed) | `argon_blueshift` on 16 threads 0.42 s -> 0.34 s; the Python march's decisions bit for bit | +| Radial and free planes' local statistics in the engine; the plane's admittance kept | radial on 16 threads 0.65 s -> 0.44 s, `line` 0.27 s -> 0.18 s (native's 0.20 s) | +| State-sized copies as the pool's tasks | a Cartesian 192² window on 16 threads 1.01 s -> 0.78 s (native's 0.85 s): one thread's copy of its 226 MB state took 45 ms, and a step made seven | +| A heavy pass splits from a few hundred elements | `argon_blueshift`'s Adams predictor on 16 threads 50 ms -> 5 ms (its 1601 elements ran serially) | +| Products with a thin side (at most eight columns or terms) as blocked loops, not BLAS | `argon_blueshift`'s plasma projections on 16 threads 54 ms -> 22 ms | +| The collar's half-step factor once a sample, not once an element | radial commits on 16 threads 31 ms -> 17 ms | +| A varying guide's power weight rebound alone, warmed at construction | `rdw`'s 12 planes 37 ms of binding -> none | +| GPU: heavy reductions a thread an element; batched transforms; one kernel a trapezoid increment | the A40's binary64 geometric mean 2.77 -> 2.32 | +| GPU: column and row sums, local sums and occupancy by device reductions | (from the MI325X's trace; measured in the ledger) | +| The split collar on the engine's march; a plasma integral's FIR in one pass | radial off the Python march; `ctc_reduced`'s integral 0.50 ms -> 0.27 ms | +| Nothing left to compile in a run's first window | radial on 16 threads 0.63 s -> 0.40 s, `line` 0.21 s -> 0.14 s (the worker's warm-up runs without a monitor) | + +The vectorised functions paid only once the live samples were gathered and each pass +was a function of its own: in the column's branchy loop, and inside its closure, LLVM +kept them scalar, and a table lookup in a loop keeps LLVM from vectorising it, so the +rate is a vectorised `log`, the lookup and a vectorised `exp`, three passes. + +## Where it stands + +Julia's window time over native's, 2 % of each case, both arms in one interpreter, the +same steps and binary64 fields equal to rounding (1e-13 or better); the ledger has the +seconds, the machines and the earlier rows. + +| case | Xeon, 1 thread | Xeon, 16 threads | A40, binary64 | A40, binary32 | H200 | MI325X | +|---|---:|---:|---:|---:|---:|---:| +| rdw | 1.52 | 1.04 | 2.86 | 3.05 | 2.02 | 2.03 | +| argon_blueshift | 1.51 | 1.21 | 2.80 | 2.24 | 2.56 | 2.33 | +| h2_raman_6ps | 1.24 | 0.89 | 1.02 | 0.66 | 1.96 | 1.71 | +| ctc_reduced | 1.56 | 0.90 | 1.47 | 1.49 | 1.98 | 2.27 | +| radial_filament_256 | 0.97 | 1.12 | 2.05 | 2.27 | 4.42 | 4.85 | +| kerr_beam_192 | 1.10 | 1.26 | 2.75 | 3.63 | 1.69 | 3.44 | +| line | 1.08 | 0.78 | 1.68 | 2.24 | 2.92 | 1.89 | + +Intel Xeon Gold 6240 (16 cores of socket 1, quiet) and the NVIDIA A40 (binary64) at +commit `a6722029`, geometric means 1.13 and 1.97; the A40's binary32 and the NVIDIA H200 +(binary64) at `50158fa6`, 1.99 and 2.39, before the first window stopped compiling, which +cost radial and the free-space windows most (radial 0.53 s -> 0.35 s on the A40); the AMD Instinct MI325X (binary64) against +native's HIP build at `196baa51`, before the GPU's column reductions, 2.48. On GPUs with +full-rate binary64 the windows are host-bound (the launches, copies and allocations a +step), which is what is left there. Binary32 is against native's binary64. Ratios measured before +the harness fix (#557) counted 0.18 s of metadata on both arms and are not comparable. + +## What is left, measured + +- **The march's host events.** The Adams march runs in the engine (`src/march.jl`) + and returns at each plane, monitor check and statistics row; a split collar, a + replayed schedule and interpolated planes keep the Python march. +- **Host statistics per plane.** The spectra, and the reductions over the engine's + power and fluence, are the shared host functions: about 1.4 ms a plane on `rdw`. +- **Small states on many threads.** With one mode and 1601 bins the passes are serial + by size, and run 20 to 40 % slower with 16 cores busy than with one (the clock). +- **Serial plasma integrals.** The two running integrals are sequential by design. +- **Binary32 on x86.** It runs (fields 1e-6 from binary64), but two to three times + slower than binary64 on the Xeon. Subnormals are not the cause: flushing them + (`SOLPROP_JULIA_FTZ=1`) left every window within its rounds' spread. Not yet found. +- **The A40's binary64.** It runs at 1/64 of its binary32 rate; the A40 says little about + an H200 or an MI325X. Binary32 with the double-float wide type (below) takes it out of + the operator and the phi functions, and the windows barely move (0.99): the host is + what is left there too. +- **Metal.** The capillary windows are bound by waits on the device. On the M5 Max a + queued kernel launch costs 4.8 us, but each value the host waits for costs about + 0.2 ms: a launch and `synchronize` 160 us, a reduction read back 210 us, a 40 kB copy + to the host 190 us (CUDA's are tens of microseconds). The trial's norms, the + quadrature alarm, the monitor and the statistics each wait; fewer of them a step (the + sums fused and read once, or kept on the device until the march needs them) is the + next lever. The section timers put `commit` (its alarm's transforms and reduction) + at about 1.2 ms a step on `rdw` and `argon_blueshift`. `h2_raman_6ps`'s strided + products are fixed (0.76); its Raman products and projections are still its largest + share. Construction compiles the Metal kernels (about 28 s), with no precompiled + trace for the device. + +## Apple silicon and Metal (2026-11-07) + +On the M5 Max the engine is faster than native on the CPU, and runs on its GPU. The +ledger has the rows. + +- **CPU, binary64.** 2 % windows on 1, 6 and 18 threads: 0.83 over native (16 of 21 + rows faster); on 6 threads with 30 s idle between workers 0.79. Whole runs on 6 threads: 0.82 (`ctc_reduced` 0.71, `h2_raman_6ps` 0.82 + over 63 s, the Cartesian beam 1.02), the same steps, fields to 1e-11. On one thread + the two are close (0.84 to 1.23); the gap opens with threads, as native's OpenMP + regions slow on the 12 second-tier cores (eight threads already slower than six, 18 + at 1.4 to 1.5 times six's time) where Polyester's tasks lose less. +- **Accelerate.** Apple's BLAS for the products is the default on macOS: radial's + window on one thread 1.02 s -> 0.60 s, no case slower. +- **Metal.** `SolpropJuliaMetalExt` (Metal.jl 1.12), binary32 only. Every binary32 + window passes against `numpy_ref`. Against native's binary64 on six CPU threads 1.95 + (the Cartesian beam 0.33, radial 0.92, the capillaries 3 to 6); against `mlx` 1.25 + (the Cartesian beam 0.71, radial and `ctc_reduced` 0.96, `h2_raman_6ps` 2.1). + Metal.jl's FFTs (MPSGraph) cover every plan form the engine uses without MLX's + Bluestein cliff; its float32 GEMM is full precision, not TF32. +- **Double-float.** An Apple GPU has no binary64, so a binary32 run there forms the + operator's exponents, the propagators and the Adams phi functions in `DF32`, a value + as two binary32s (about 48 bits; `src/dfloat.jl`, the mlx backend's primitives), each + result rounded once to binary32. `SOLPROP_JULIA_WIDE=df32` takes it on any device; + binary64 runs keep their arithmetic exactly. Its phi functions agree with binary64's + to within 2^-36, its propagator pair to 8 binary32 ulps up to a 1e6 rad phase. +- **Measurement.** Absolute times on the Mac moved by up to 40 % over a day of + benchmarks, with no thermal warning; the ratio did not (0.79 to 0.88 over every + variant: windows, whole runs, 30 s idle between workers, single-backend passes back + to back). Quote ratios from interleaved arms, not absolute times from different runs. + +## Floating point (2026-11-07) + +SEP 25 permits contraction and per-kernel reassociation and forbids umbrella fast-math, +approximations and flush-to-zero. The engine now contracts its ordinary kernels (the +stage combinations, the Adams sums, the phi series, the plasma rate's cubic, the FIR +sums); the protected helpers, the march's decisions, the defects and the norms stay as +written, and the CPU column scan's order is a choice, not policy. Contraction measured +0.99 on the M5 Max (`h2_raman_6ps` 0.93 to 0.96 the only steady gain): the engine is +bound by passes over memory, not by operations. + +Flush-to-zero, as an experiment (`SOLPROP_JULIA_FTZ=1`, #561), helped nowhere: 1.00 on +the M5 Max in binary32, 0.99 on the Xeon in binary32. It is also hazardous embedded in +Python: Julia's first thread is the interpreter's own, and a flag set there flushed +NumPy's subnormals too, failing a `math.log` in solprop's translation. The switch flushes +only inside the engine's entry points. + +## Toward a first-class backend + +What these measurements say about Julia becoming a supported backend beside, or in +place of, native and `mlx`. + +**For.** +- **Speed on a CPU.** Faster than native on the M5 Max (0.82 over whole runs), within + 13 % on the Xeon at 16 threads, faster in some rows there. +- **One source for every device.** About 3,500 lines of engine (plus the 1,600-line + compile trace and a 2,400-line adapter), against about 31,000 of native's C++. The + same scalar bodies run on CPUs, NVIDIA, AMD and now Apple GPUs; Kokkos has no Metal + backend. Intel GPUs (oneAPI.jl) should take an extension like the others. +- **A replacement for `mlx`.** Within 25 % of the hand-written `mlx` backend on its own + GPU on the first, unprofiled run, faster on the largest case. +- **Iteration.** Each device extension so far took an hour or two; the double-float + path was a day's work and runs on every device. + +**Against, or not yet.** +- **GPU speed.** About twice native on full-rate GPUs (H200 2.39, MI325X 2.48, not + re-measured since), host-bound: launches (about 75 a trial), copies and allocations. + CUDA graphs or fused trials are the next step, untried. +- **Coverage.** Julia refuses much of what native runs beyond the focus routes (the + list below). Of what `mlx` runs, only the on-axis plasma statistics, vector + polarisation and tensor Raman are left (2026-11-08). +- **Distribution and start.** A Julia runtime and a 1.8 GB depot beside the wheel; + the first engine in a process compiles for 11 to 14 s on a CPU (after the + precompiled trace) and about 28 s on Metal. A PackageCompiler system image, untried, + would remove most of it. Native ships as a prebuilt wheel on PyPI. +- **Qualification.** No CI lane runs it. The double-float path has window tests and + unit bounds, not `mlx`'s SEP 33 drift and envelope qualification. +- **The toolchain's own bugs.** Julia's LinearAlgebra gave wrong concurrent + `Complex{Float32}` products (worked around); juliacall shares the interpreter's thread. + +**The decisions a SEP would take.** Whether Julia replaces native, sits beside it, or +replaces only `mlx`; which features it must cover before that; how it ships (system +image, `juliapkg`, or a separate distribution); which CI lanes run it (a CPU lane, and a +GPU lane somewhere); and whether the double-float path takes `mlx`'s qualification. +The cheapest step with the most information is to replace `mlx` first: profile Metal +on the losing cases, add `mlx`'s features, run SEP 33's qualification on `df32`, and +compare again. + +## The evening's work (2026-11-07) + +**Metal against `mlx`: 0.66** (1.25 in the morning), Julia faster in six of seven +cases. The changes, each A/B'd on Metal (the ledger has the rows): +- A chunk's constant projection rows kept contiguous (`table_rows`). +- Device copies as one kernel, views included (`device_copy!`): Metal.jl's `copyto!` + into a view cost about 200 us. +- One value the host waits for a step (`sum_device!`, the alarm read with the norms). +- One chunk of nodes a source on a GPU (`node_chunk`). +- The trial's tables in one upload (`device_tables`). +- The population statistics in one parallel reduction and one readback. +- A source's forward streams packed into one transform (modal and free space). +- A GPU state copied to the host once a state (`engine.version`, `copy_state!`). +- The free-space operator's tables on every GPU (binary64 too). +- The analytic signal from the spectrum (as native forms it; no benchmark case uses + it). + +**`mlx`'s features: 13 of 14 closed** (varying Raman, Adams in free space and +envelope plasma on 2026-11-08, below), and of the evening's list each tested against `numpy_ref` (binary64, +fields within 1e-10, most about 1e-15): lockstep batches, TSIT5, modal RK4IP, +several Raman components, tapers, the window statistics and `zdw`, resolved and radial +envelopes, the envelope's third harmonic, Raman in free space, several plasma channels. + +## 2026-11-08 + +Three more `mlx` features, each against `numpy_ref` on DMOG (57 tests pass on the CPU +and on the A40 at `a23cfd3f`): +- **Varying Raman.** Each term's decay rate and each component's density are stage + tables; the kernel is rebuilt when they change (`rebuild_raman!`). Hydrogen's lines + shift with density, which the Raman seam cannot follow along a gradient, so the + test holds the shift at the reference density (`MaterialSelection`). +- **Adams in free space.** The host-formed rate table is the Adams operator; a `line` + window on the multistep stepper, binary64 within 1e-10 and binary32 within 1e-4. +- **Envelope plasma** (`julia/src/envelope.jl`). The oracle's cycle quadrature per + sample (rules of 64 to 512 points, split at the table's cutoffs, refined to 2e-6), + the running trapezoid of the rate, and the drive and loss currents through the field + plasma's projected, transformed streams with -1/omega^2 and -i/omega. Binary32's + refinement needs `mlx`'s precise table evaluation (`precise_rate`: the local + coordinate `log1p(E/E_i - 1)` and a two-sum constant term); a binary32 `log E` put + 4e-5 of noise in the rate and no two rules agreed. Scalar polarisation only, as + everywhere; a sample that does not converge is NaN and the step's norm refuses it + (the oracle raises `ConvergenceError`). + +The A40 at `137c6915`: 0.97 against `9d814979`; native against Julia 1.81 in binary64 +and 1.48 in binary32 df32 (the ledger's table). + +**The on-axis plasma statistics** (`51ef674e`): through the driver's shared form, on +the field and envelope grids, against `numpy_ref`. That closes `mlx`'s list but for +vector polarisation and tensor Raman (deferred). + +**Envelope plasma on Metal.** Binary32 missed the frozen 2e-6 refinement at a few +samples of most runs, on `mlx` too: `mlx` raises `ConvergenceError` on the test's +argon capillary and waveguide at 0.1 to 0.6 mJ (a finding about `mlx`, not filed). +Two causes: Metal's `sin`/`cos` are 2 to 3 ulp (Julia's binary32 ones on a CPU 0.5), +which near the table's low cutoff, where the rate is steepest in the field, is more +noise than the budget; and the sine moment, which a scalar envelope never uses, has +the rate times tan^2 for its integrand. Polynomial `sin`/`cos` on [0, pi/2] +(`quadrant_sincos`, about 1 ulp on every device) and the cosine moment alone required +to converge make every case converge, on Metal and on CPUs. + +**Where the A40's binary64 time goes** (`rdw`, jl15's node-traced profile): Julia's +kernels take 80 ms against native's 32, and 19 ms of Julia's are 195 cuFFT +transforms of 5120 points at 96 us each. cuFFT runs a binary64 transform of a few +thousand points as one block (96 us at 5120, 138 at 10240, any batch, cuFFT 12.4 and +11.3 alike), while a 2D 512 x 10 transform takes 12 us; native's are mostly a +two-kernel split. A four-step split (`LongFFT`: the short transforms strided, the +twiddles, the long ones contiguous) takes 23 us at either size, errors 1e-17 +(`scripts/fft_fourstep2.jl` on DMOG); the engine now plans one on CUDA for binary64 +transforms of 2048 points or more (`SOLPROP_JULIA_FOURSTEP=0` turns it off). The +Cartesian transverse transform through a transverse-first copy (`Transposed`) gives +0.92 on `kerr_beam_192` and 0.89 on `line` on the A40 (binary64), and 1.10 and 1.09 +on Metal, so it is CUDA's only. + +## 2026-11-08, the GPU host + +On the A40, in binary64, native against Julia went from 1.80 in the morning to 1.15 at +`51a153de` (binary32 df32 from 1.56 to 0.79: Julia faster in five of seven cases), and +the H200 at `67491bf9` was 1.69 (2.39 before), an H100 at `6f686ea4` (with the graphs and +the copy fix) is 1.25, and an AMD MI300X at `1b17fc75` 1.28 (the MI325X's was 2.48), +without graphs, which are CUDA's only so far. In order of what each change bought on the A40 (the ledger has every row): +- **Kernel bodies inlined** (`@inline f(t, m)` in the GPU kernel): left to the + inliner, a body was a device call per sample with its arguments in local memory, + 9 times slower in binary64 and 20 in binary32. 0.70 / 0.62 over the seven cases. + Metal's compiler inlines them itself (1.01). +- **Source graphs** (`graph_source!`): a source's passes, kernels, cuFFT and cuBLAS, + captured once and replayed (host 4 us against 300 to 650), its stage scalars read + from a device vector so that a gradient replays one graph. 0.95 / 0.89. +- **Four-step long FFTs** (`LongFFT`): cuFFT runs a binary64 transform of a few + thousand points as one block (96 us at 5120); split, 23 us. 0.99 overall, 0.92 to + 0.94 on the plasma capillaries. +- **Transverse-first copies** of the Cartesian planes, tiled: 0.89 to 0.95 on the + free-space cases (CUDA only; Metal's strided transforms are faster as they are). +- **Direct state copies**: a large state straight between the device and the reader's + buffer (three host passes and two allocations were 0.29 s of `kerr_beam_192`'s + 0.42 s window). `kerr_beam_192` 0.56, about 1.24 against native. + +What is left on a full-rate card (the H200) is the host: Julia's times there are the +A40's, where native's halve. Per Adams step the host still makes about 11 launches +outside the graph (predictor, corrector, commit), the trial's table upload and the +norm's readback, the step controller's true dependency; per saved plane the statistics +take about 2 ms (`rdw`'s 12 planes in a 2 % window are a third of it). A whole-trial +graph was tried and reverted: its kernels take the Adams order as a value, so a +variable-order run captured a graph for each order it met (1.60). + +## Next steps + +Roughly in order of what they would tell. + +1. **`line` on Metal (1.5 against `mlx`).** GPU-bound (host Python under 10 %, + Julia's host time about a fifth); the statistics' readbacks are fixed (observe 4.7 + of 195 ms). What is left is the source: fusing `source_free!`'s and the DOPRI + stage's elementwise passes would save perhaps 5 ms. +2. **The GPU host, continued.** Nsight per-step timelines against native + (`scripts/step_timeline.py` on DMOG) show the device's work equal on + `argon_blueshift` and Julia's step idle 164 us against native's 88 (A40, binary64). + Tried and reverted, each with its numbers in the ledger: a whole-trial graph (an + order-dependent key), an order-independent one (phi functions to the largest width + cost more), fused device reductions (`ctc_reduced` 10 to 20 % slower in binary32). + What is left to try: a plane's observations in one Julia call (a plane's window on + `rdw` holds about 1.1 ms of host time with no CUDA call, between the adapter's + separate Python-to-Julia calls; the ledger has the sequence), the GEMMs' scalars + uploaded once rather than per call, and graphs on ROCm (AMDGPU.jl's stream capture, + untried; the MI300X runs without them). +3. **The A40's remaining kernels:** the Adams predictor (0.1 to 0.28 ms a trial, its + phi functions spilling, latency-bound on a mode-averaged state's few thousand + elements) and radial's CUTLASS binary64 GEMMs (the A40 has no binary64 tensor + cores). +4. **Metal start latency** (about 28 s of kernel compilation): a recorded trace or a + system image. +5. **Binary32 on x86**, two to three times binary64 on the Xeon, not subnormals. +6. **Pro GPUs** (H200, MI325X; DigitalOcean, a US$30 cap approved), after 3. + +The working setups: on the Mac a worktree with native built on the NEON FFTW prefix +(`~/buildtools/fftw-3.3.11-neon`) and `uv sync --extra julia --extra mlx`; an A/B of +two Julia trees runs the baseline through a wrapper interpreter that sets +`SOLPROP_JULIA_ROOT` (never edit a tree a benchmark is loading). On DMOG +`/mnt/data/shared/jt52/solprop-julia-20261106`: `jl17-a40.sbatch` (a tree from `git +archive`, jl12's native CUDA wheel, the tests, the previous tree against this one, and +native against both precisions), `jl15-nsys*.sbatch` (Nsight profiles through +`scripts/prof_case.py`). On the Xeon `~/awork/solprop-julia-ftz-20261107`. The raw data +are in the private `solprop-dev/benchmarks/julia-m5-2026-11-07` and +`julia-gpu-2026-11`. + +## Not run + +Vector polarisation and tensor Raman, noise, varying Raman coefficients beside a +constant operator or in free space, dispersive Kerr, TDSE, planar and general modal +guides, coupled flows, the interaction Adams formulation, the carrier frame, interpolated +planes, low-storage integration with a varying operator, tableaux other than DOPRI5 and +TSIT5, and the on-axis plasma statistics are refused by name; so is binary64 on Metal. + +## Findings for main + +- `parallel_rows` read the CPU topology from sysfs (a file per CPU) before deciding a + pass was too small to thread: 60 ms of a 0.36 s rdw window. Fixed on this branch; + #556. +- `benchmarks.worker.timed_run` evaluated `simulation.metadata()` inside the timed + window, and its first evaluation costs about 0.18 s on rdw (the plane bases' modal + identity): every arm's first timed repeat, native's included, paid it. Fixed on this + branch; ratios measured before it understate both arms' speed (native's `rdw` window + on 16 threads is 0.145 s, not 0.314 s); #557. +- Julia's LinearAlgebra gave wrong products for concurrent `mul!` calls on views of a + `Complex{Float32}` matrix times a `Float32` one (relative error 1.5); the engine forms + them as real GEMMs over the complex array's real view instead. +- `docs/dev/backends.md` still names `set_held_plane` and `held_observation`, which + main removed; #558. +- On the M5 Max native is slower on 8 and on 18 threads than on 6, on most cases: its + parallel regions wait for the second-tier cores. OpenMP's `active` waiting does not + change it. Not filed yet. +- On the Mac absolute times drift by up to 40 % over a day of sustained benchmarking + (no thermal warning recorded); only interleaved ratios are comparable across runs. + `benchmarks ab --cooldown` (this branch) idles between workers; 30 s did not undo it. diff --git a/julia/bench/Manifest.toml b/julia/bench/Manifest.toml new file mode 100644 index 000000000..0ccd38909 --- /dev/null +++ b/julia/bench/Manifest.toml @@ -0,0 +1,995 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "c560532eae82ee8bc885fc8fd09c5b5f824bb120" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.AcceleratedKernels]] +deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] +git-tree-sha1 = "ac481710a9eee43b1d8dbd1e26a49a19de71475a" +registries = "General" +uuid = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +version = "0.5.11" + + [deps.AcceleratedKernels.extensions] + CUDACoreExt = "CUDACore" + MetalExt = "Metal" + OpenCLExt = "OpenCL" + oneAPIExt = "oneAPI" + + [deps.AcceleratedKernels.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.Accessors]] +deps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "MacroTools"] +git-tree-sha1 = "8c0bc12397dabf5d2dfc4b5763ec463854cc44d3" +registries = "General" +uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" +version = "0.1.46" + + [deps.Accessors.extensions] + AxisKeysExt = "AxisKeys" + IntervalSetsExt = "IntervalSets" + LinearAlgebraExt = "LinearAlgebra" + StaticArraysExt = "StaticArrays" + StructArraysExt = "StructArrays" + TestExt = "Test" + UnitfulExt = "Unitful" + + [deps.Accessors.weakdeps] + AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5" + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "eec8a0ad4e4b673afba213931504c360fffb8f97" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.8.0" + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + + [deps.Adapt.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +registries = "General" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "0aa371c875e24cf773c87b2f50ab03e4545748af" +registries = "General" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.7.0" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + +[[deps.BangBang]] +deps = ["Accessors", "ConstructionBase", "InitialValues", "LinearAlgebra"] +git-tree-sha1 = "cceb62468025be98d42a5dc581b163c20896b040" +registries = "General" +uuid = "198e06fe-97b7-11e9-32a5-e1d131e6ad66" +version = "0.4.9" + + [deps.BangBang.extensions] + BangBangChainRulesCoreExt = "ChainRulesCore" + BangBangDataFramesExt = "DataFrames" + BangBangStaticArraysExt = "StaticArrays" + BangBangStructArraysExt = "StructArrays" + BangBangTablesExt = "Tables" + BangBangTypedTablesExt = "TypedTables" + + [deps.BangBang.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BenchmarkTools]] +deps = ["Compat", "JSON", "Logging", "PrecompileTools", "Printf", "Profile", "Statistics", "UUIDs"] +git-tree-sha1 = "9670d3febc2b6da60a0ae57846ba74670290653f" +registries = "General" +uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +version = "1.8.0" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +registries = "General" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.ChunkSplitters]] +git-tree-sha1 = "1c52c8e2673edc030191177ff1aee42d25149acb" +registries = "General" +uuid = "ae650224-84b6-46f8-82ea-d812ca08434e" +version = "3.2.0" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerCaching]] +deps = ["LMDB", "SHA", "Scratch"] +git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" +registries = "General" +uuid = "9db33cc3-5358-4881-8759-fa4194144afd" +version = "0.5.3" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CompositionsBase]] +git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad" +registries = "General" +uuid = "a33af91c-f02d-484b-be07-31d278c5ca2b" +version = "0.1.2" +weakdeps = ["InverseFunctions"] + + [deps.CompositionsBase.extensions] + CompositionsBaseInverseFunctionsExt = "InverseFunctions" + +[[deps.ConstructionBase]] +git-tree-sha1 = "b4b092499347b18a015186eae3042f72267106cb" +registries = "General" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.6.0" + + [deps.ConstructionBase.extensions] + ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseLinearAlgebraExt = "LinearAlgebra" + ConstructionBaseStaticArraysExt = "StaticArrays" + + [deps.ConstructionBase.weakdeps] + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "f60436514e6d73f8ee069ae4ee0ff038fe96b69d" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.2" + +[[deps.GPUCompiler]] +deps = ["CompilerCaching", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "REPL", "ScopedValues", "TOML", "Tracy", "UUIDs", "tree_sitter_gcn_jll", "tree_sitter_llvm_jll", "tree_sitter_ptx_jll", "tree_sitter_spirv_jll"] +git-tree-sha1 = "65175d8064f99fc7a27cc9b69bed573b35ee080e" +registries = "General" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "2.21.0" + + [deps.GPUCompiler.extensions] + CthulhuExt = "Cthulhu" + HighlightsExt = "Highlights" + + [deps.GPUCompiler.weakdeps] + AMDGPU_LLVM_Backend_jll = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" + Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f" + Highlights = "eafb193a-b7ab-5a9e-9068-77385905fa72" + LLVMDowngrader_jll = "f52de702-fb25-5922-94ba-81dd59b07444" + NVPTX_LLVM_Backend_jll = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" + SPIRV_LLVM_Backend_jll = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" + SPIRV_LLVM_Translator_jll = "4a5d46fc-d8cf-5151-a261-86b458210efb" + +[[deps.GPUToolbox]] +git-tree-sha1 = "a380d7a5bf9be3fb1e85344c683bab446f4861c0" +registries = "General" +uuid = "096a3bc2-3ced-46d0-87f4-dd12716f4bfc" +version = "3.5.1" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.InitialValues]] +git-tree-sha1 = "4da0f88e9a39111c2fa3add390ab15f3a44f3ca3" +registries = "General" +uuid = "22cec73e-a1b8-11e9-2c92-598750a2cf9c" +version = "0.3.1" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.InverseFunctions]] +git-tree-sha1 = "5cc6ad3e2bfc75a11eed92632ee341d37f4a4536" +registries = "General" +uuid = "3587e190-3f89-42d0-90ee-14403ec27112" +version = "0.1.18" + + [deps.InverseFunctions.extensions] + InverseFunctionsDatesExt = "Dates" + InverseFunctionsTestExt = "Test" + + [deps.InverseFunctions.weakdeps] + Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "06d90f699285d055e34f0b014636a75a17ff2252" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.13.4" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + JSONSerializationExt = ["Serialization"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "MacroTools", "PrecompileTools", "Printf", "Random", "Random123", "RandomNumbers", "SPIRVIntrinsics", "SPIRV_LLVM_Backend_jll", "SPIRV_Tools_jll", "StaticArraysCore", "UnsafeAtomics", "pocl_standalone_jll"] +git-tree-sha1 = "0b9e978d21df1aa3ead81c89a2bdf3c6f063a39c" +registries = "General" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.10.5" + + [deps.KernelAbstractions.extensions] + AMDGPUExt = "AMDGPU" + LinearAlgebraExt = "LinearAlgebra" + MetalExt = "Metal" + SparseArraysExt = "SparseArrays" + StaticArraysExt = "StaticArrays" + oneAPIExt = "oneAPI" + + [deps.KernelAbstractions.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.KernelInterface]] +git-tree-sha1 = "62300ced3fd046f4694e8dbf0e2fbc2bed84f371" +registries = "General" +uuid = "4ee993da-d684-4d17-a7dd-4e58e78d92bf" +version = "0.4.5" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "PrecompileTools", "Preferences", "Printf", "ScopedValues", "Unicode"] +git-tree-sha1 = "41c2ce7ec5a14c89b93dc6a5853bf2a91d7a8583" +registries = "General" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "10.4.3" + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + + [deps.LLVM.weakdeps] + BFloat16s = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "39def0b4521e0ef2bf26960d8965729f496bb4ec" +registries = "General" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.56+0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LMDB]] +deps = ["CEnum", "LMDB_jll"] +git-tree-sha1 = "84e5cba87693714bfd67f589a91f24a996ff3e69" +registries = "General" +uuid = "11f193de-5e89-5f17-923a-7d207d56daf9" +version = "3.0.1" + +[[deps.LMDB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "196c962b4d66b978b9be1e15e4e1d53441d5f028" +registries = "General" +uuid = "6206cf0b-f360-5984-af49-5437264c140e" +version = "1.0.3+0" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +registries = "General" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.OhMyThreads]] +deps = ["BangBang", "ChunkSplitters", "ScopedValues", "StableTasks", "TaskLocalValues"] +git-tree-sha1 = "a73a90d87e3f941f5084d34d56934c2fb59dd9b1" +registries = "General" +uuid = "67456a42-1dca-4109-a031-0a68de7e3ad5" +version = "0.8.9" + + [deps.OhMyThreads.extensions] + MarkdownExt = "Markdown" + ProgressMeterExt = "ProgressMeter" + + [deps.OhMyThreads.weakdeps] + Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a" + ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools"] +git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "3.0.6" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.Profile]] +deps = ["StyledStrings"] +uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" +version = "1.11.0" + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +registries = "General" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +registries = "General" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEF_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" +registries = "General" +uuid = "63e82ce6-3d80-5af4-a84c-484b71ab98bb" +version = "3.9.0+2" + +[[deps.SPIRVIntrinsics]] +deps = ["GPUToolbox", "LLVM", "UnsafeAtomics"] +git-tree-sha1 = "2ee2b6f667d53d1f03079ce7179f7de7ef5058b7" +registries = "General" +uuid = "71d1d633-e7e8-4a92-83a1-de8814b09ba8" +version = "1.6.0" + + [deps.SPIRVIntrinsics.extensions] + SPIRVIntrinsicsSIMDExt = "SIMD" + SPIRVIntrinsicsSIMDSpecialFunctionsExt = ["SIMD", "SpecialFunctions"] + SPIRVIntrinsicsSpecialFunctionsExt = "SpecialFunctions" + + [deps.SPIRVIntrinsics.weakdeps] + GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55" + SIMD = "fdea26ae-647d-5447-a871-4b548cad5224" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SPIRV_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "6aaddfdf3040d02a5b3e10c6cd0e4e1dce27f23c" +registries = "General" +uuid = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" +version = "23.1.4+1" + +[[deps.SPIRV_Tools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "783c358eff59056d7e703a644f5179270c43226a" +registries = "General" +uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" +version = "2025.4.0+0" + +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.StableTasks]] +git-tree-sha1 = "c4f6610f85cb965bee5bfafa64cbeeda55a4e0b2" +registries = "General" +uuid = "91464d47-22a1-43fe-8b7f-2d57ee82463f" +version = "0.1.7" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "e2b53ce13a53367e96601081e33d34746b571bad" +registries = "General" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.5" + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + + [deps.Statistics.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" +registries = "General" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.12.0" + + [deps.StructUtils.extensions] + StructUtilsDBInterfaceExt = ["DBInterface", "Tables"] + StructUtilsDataFramesExt = ["DataFrames"] + StructUtilsLazilyInitializedFieldsExt = ["LazilyInitializedFields"] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazilyInitializedFields = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.TaskLocalValues]] +git-tree-sha1 = "67e469338d9ce74fc578f7db1736a74d93a49eb8" +registries = "General" +uuid = "ed4db957-447d-4319-bfb6-7fa9ae7ecf34" +version = "0.1.3" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +registries = "General" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +deps = ["LLVM"] +git-tree-sha1 = "74ac5e0e702972da953ffc981094617070be582d" +registries = "General" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.4.0" +weakdeps = ["GPUCompiler"] + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsGPUCompilerExt = "GPUCompiler" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + +[[deps.pocl_standalone_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] +git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" +registries = "General" +uuid = "54f56a70-6062-5590-a942-1226658f6c83" +version = "7.2.3+7" + +[[deps.tree_sitter_gcn_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7aea9f731552967bda93cb7cbf6925de65bc38d5" +registries = "General" +uuid = "8b5cbfcf-8811-596e-8e87-0e51e05ee4b2" +version = "0.1.0+0" + +[[deps.tree_sitter_llvm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2fb7d0e3a8abf532fa922766ca130bf814df1e70" +registries = "General" +uuid = "44208993-ee63-5069-9443-8e43b04a9b30" +version = "1.1.0+0" + +[[deps.tree_sitter_ptx_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e6ad264eebe3e34f03bca6b5e811d80e0f4797a2" +registries = "General" +uuid = "71e3f6e6-c059-5e7c-a2f2-d560fdad7ce5" +version = "0.1.0+0" + +[[deps.tree_sitter_spirv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7d8c03949bab84b23fe0500d89979e786d54a653" +registries = "General" +uuid = "f0e86581-c468-54df-a4de-3266e11a3c86" +version = "0.1.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/julia/bench/Project.toml b/julia/bench/Project.toml new file mode 100644 index 000000000..3ff7af190 --- /dev/null +++ b/julia/bench/Project.toml @@ -0,0 +1,7 @@ +[deps] +AcceleratedKernels = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +OhMyThreads = "67456a42-1dca-4109-a031-0a68de7e3ad5" +Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" diff --git a/julia/bench/launch.jl b/julia/bench/launch.jl new file mode 100644 index 000000000..80a5091db --- /dev/null +++ b/julia/bench/launch.jl @@ -0,0 +1,79 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Time one pointwise body under each CPU launch strategy the engine could use. +# Run: julia -t N --project=julia/bench julia/bench/launch.jl +using BenchmarkTools, Polyester, OhMyThreads +import AcceleratedKernels as AK +import KernelAbstractions as KA + +@inline kerr(v, f, w) = f * (v * v) * v * w + +function serial!(out, x, w, f) + @inbounds for m in axes(out, 2) + @simd for t in axes(out, 1) + out[t, m] = kerr(x[t, m], f, w[t]) + end + end +end + +# Flat blocks of contiguous samples: the same work split for any column count. +const BLOCK = 16384 +@inline function block!(out, x, w, f, b) + nt = size(out, 1) + first, last = (b - 1) * BLOCK + 1, min(b * BLOCK, length(out)) + @inbounds @simd for i in first:last + t = i - ((i - 1) ÷ nt) * nt + out[i] = kerr(x[i], f, w[t]) + end +end +function ak!(out, x, w, f) + AK.foreachindex(1:cld(length(out), BLOCK); min_elems=1) do b + block!(out, x, w, f, b) + end +end +function poly!(out, x, w, f) + @batch for b in 1:cld(length(out), BLOCK) + block!(out, x, w, f, b) + end +end +function static!(out, x, w, f) + Threads.@threads :static for b in 1:cld(length(out), BLOCK) + block!(out, x, w, f, b) + end +end +function omt!(out, x, w, f) + tforeach(1:cld(length(out), BLOCK); scheduler=:static) do b + block!(out, x, w, f, b) + end +end +# Column-blocked with a contiguous inner loop (the prototype's host traversal). +function columns!(out, x, w, f) + AK.foreachindex(axes(out, 2); min_elems=max(1, cld(32768, size(out, 1)))) do m + @inbounds @simd for t in axes(out, 1) + out[t, m] = kerr(x[t, m], f, w[t]) + end + end +end +KA.@kernel function kerr_kernel!(out, @Const(x), @Const(w), f) + t, m = KA.@index(Global, NTuple) + @inbounds out[t, m] = kerr(x[t, m], f, w[t]) +end +function ka!(out, x, w, f) + kerr_kernel!(KA.CPU(), 1024)(out, x, w, f; ndrange=size(out)) + KA.synchronize(KA.CPU()) +end +broadcast!(out, x, w, f) = (out .= kerr.(x, f, w); nothing) + +for (nt, nm) in ((10240, 4), (20480, 64), (10240, 1024)) + x, w = randn(nt, nm), rand(nt) + out = similar(x) + println("size $nt x $nm, threads $(Threads.nthreads())") + for (name, f!) in (("serial", serial!), ("broadcast", broadcast!), ("ak-flat", ak!), + ("polyester", poly!), ("threads", static!), ("ohmythreads", omt!), + ("ak-columns", columns!), ("ka-cpu", ka!)) + t = @belapsed $f!($out, $x, $w, 0.5) + println(rpad(" $name", 16), round(t * 1e6; digits=1), " us ", + round(16e-9 * length(out) / t; digits=1), " GB/s") + end +end diff --git a/julia/bootstrap.py b/julia/bootstrap.py new file mode 100644 index 000000000..7d63024a6 --- /dev/null +++ b/julia/bootstrap.py @@ -0,0 +1,108 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Prepare the experiment's Julia runtime and instantiate its committed manifest. + +``SOLPROP_JULIA_EXE`` names an existing Julia 1.13 (for example juliaup's); without +it the checksummed official release is downloaded into ``.julia-runtime/``. The +packages go to ``SOLPROP_JULIA_DEPOT``, by default ``.julia-depot/``. +""" + +import hashlib +import os +import platform +import subprocess +import sys +import tarfile +import urllib.request +from pathlib import Path + +VERSION = "1.13.3" +# Digests published by Julia's official versions.json for these release archives. +RELEASES = { + ("darwin", "arm64"): ( + "mac/aarch64", + "macaarch64", + "b9f0e8450fbcb392aa3e8b43fa1fc09993665a31bf705d7ef8084f0ac4ad3765", + ), + ("linux", "x86_64"): ( + "linux/x64", + "linux-x86_64", + "5c61cb4b40332cb5a3504e7779e2f5dac093caa4a1116ded19f01413f85c63e4", + ), + ("linux", "aarch64"): ( + "linux/aarch64", + "linux-aarch64", + "9ceb053bee6dfb8189bd40afd6925de3a9b7ff8fac8d01a5fcdd84af171ddf03", + ), +} +ROOT = Path(__file__).resolve().parents[1] + + +def executable() -> Path: + """Return the Julia executable, downloading the checksummed release if needed.""" + if named := os.environ.get("SOLPROP_JULIA_EXE"): + return Path(named) + release = RELEASES.get((sys.platform, platform.machine())) + if release is None: + raise RuntimeError("no Julia release is recorded for this platform") + directory, suffix, expected = release + private = ROOT / ".julia-runtime" + binary = private / f"julia-{VERSION}/bin/julia" + if binary.is_file(): + return binary + private.mkdir(exist_ok=True) + name = f"julia-{VERSION}-{suffix}.tar.gz" + archive = private / name + if not archive.is_file(): + url = f"https://julialang-s3.julialang.org/bin/{directory}/1.13/{name}" + urllib.request.urlretrieve(url, archive) + with archive.open("rb") as stream: + if hashlib.file_digest(stream, "sha256").hexdigest() != expected: + raise RuntimeError("Julia archive SHA256 does not match the release") + with tarfile.open(archive) as bundle: + bundle.extractall(private, filter="data") + return binary + + +def main() -> None: + """Instantiate and precompile the Julia project.""" + env = os.environ | { + "JULIA_DEPOT_PATH": os.environ.get( + "SOLPROP_JULIA_DEPOT", str(ROOT / ".julia-depot") + ), + "JULIA_LOAD_PATH": "@:@stdlib", + "JULIA_CONDAPKG_BACKEND": "Null", + "JULIA_PYTHONCALL_EXE": sys.executable, + } + # --cuda (--rocm, --metal) also prepares the GPU environment, which adds CUDA.jl + # (AMDGPU.jl, Metal.jl) to the engine's. + projects = ["julia"] + [ + f"julia/{gpu}" + for gpu in ("cuda", "rocm", "metal") + if f"--{gpu}" in sys.argv[1:] or (gpu == "cuda" and "--cuda-local" in sys.argv) + ] + # --cuda-local: CUDA.jl takes the system toolkit rather than its own, needed where + # native is built against a system CUDA in the same process, whose cuBLAS would + # otherwise meet CUDA.jl's own (an undefined cublasLt symbol, CUDA 13.1 on an H200). + if "--cuda-local" in sys.argv[1:]: + (ROOT / "julia/cuda/LocalPreferences.toml").write_text( + '[CUDA_Runtime_jll]\nlocal = "true"\n', encoding="utf-8" + ) + for project in projects: + subprocess.run( + [ + str(executable()), + "--startup-file=no", + f"--project={ROOT / project}", + "-e", + "using Pkg; Pkg.instantiate(); Pkg.precompile()", + ], + env=env, + check=True, + ) + sys.stdout.write("Prepared Julia and julia/Manifest.toml\n") + + +if __name__ == "__main__": + main() diff --git a/julia/cuda/Manifest.toml b/julia/cuda/Manifest.toml new file mode 100644 index 000000000..3b7bd16b4 --- /dev/null +++ b/julia/cuda/Manifest.toml @@ -0,0 +1,1197 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "7636c761c1c4063c6f7788bd9869f847b902626f" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.AcceleratedKernels]] +deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] +git-tree-sha1 = "ac481710a9eee43b1d8dbd1e26a49a19de71475a" +registries = "General" +uuid = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +version = "0.5.11" + + [deps.AcceleratedKernels.extensions] + CUDACoreExt = "CUDACore" + MetalExt = "Metal" + OpenCLExt = "OpenCL" + oneAPIExt = "oneAPI" + + [deps.AcceleratedKernels.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "eec8a0ad4e4b673afba213931504c360fffb8f97" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.8.0" + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + + [deps.Adapt.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +registries = "General" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "0aa371c875e24cf773c87b2f50ab03e4545748af" +registries = "General" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.7.0" +weakdeps = ["CUDA", "CUDACore"] + +[[deps.BFloat16s]] +deps = ["LinearAlgebra", "Printf", "Random"] +git-tree-sha1 = "59ba860cf4d7e2fe58f35c8d08cfe765b6c33655" +registries = "General" +uuid = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" +version = "0.6.5" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +registries = "General" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.CUDA]] +deps = ["CUDACore", "CUDATools", "Reexport", "cuBLAS", "cuFFT", "cuRAND", "cuSOLVER", "cuSPARSE"] +git-tree-sha1 = "c82345f5d7e0d902793b4ad5ddf61c2a8b6aac75" +registries = "General" +uuid = "052768ef-5323-5732-b1bb-66c8b64840ba" +version = "6.5.1" + +[[deps.CUDACore]] +deps = ["Adapt", "BFloat16s", "CEnum", "CUDA_Compiler_jll", "CUDA_Driver_jll", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUArrays", "GPUCompiler", "GPUToolbox", "KernelAbstractions", "KernelInterface", "LLVM", "LLVMLoopInfo", "LazyArtifacts", "Libdl", "LinearAlgebra", "Logging", "NVPTX_LLVM_Backend_jll", "PrecompileTools", "Preferences", "Printf", "Random", "Random123", "RandomNumbers", "ScopedValues", "UnsafeAtomics"] +git-tree-sha1 = "ad63644ab7a9fca22269c196e539d6c2ad75e841" +registries = "General" +uuid = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" +version = "6.5.1" + + [deps.CUDACore.extensions] + ChainRulesCoreExt = "ChainRulesCore" + EnzymeCoreExt = "EnzymeCore" + SpecialFunctionsExt = "SpecialFunctions" + StaticArraysExt = "StaticArrays" + + [deps.CUDACore.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.CUDATools]] +deps = ["CUDACore", "CUDA_Compiler_jll", "CUPTI", "Crayons", "GPUCompiler", "KernelInterface", "LLVM", "NVML", "NVTX", "PrecompileTools", "Preferences", "PrettyTables", "Printf", "Statistics", "demumble_jll"] +git-tree-sha1 = "de1d79e7ea89bbc09b844af32d651c77a9b6e300" +registries = "General" +uuid = "9ec180c6-1c07-47c7-9e6e-ebefa4d1f6d0" +version = "6.5.1" + +[[deps.CUDA_Compiler_jll]] +deps = ["Artifacts", "CUDA_Driver_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "TOML"] +git-tree-sha1 = "d25781968aff72a9d8d5bd979b7805d154ab45a0" +registries = "General" +uuid = "d1e2174e-dfdc-576e-b43e-73b79eb1aca8" +version = "0.6.4+0" + +[[deps.CUDA_Driver_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "8794abb9272b6c0791863549ab3aa32eee29bf7d" +registries = "General" +uuid = "4ee394cb-3365-5eb0-8335-949819d2adfc" +version = "13.5.0+0" + +[[deps.CUDA_Runtime_Discovery]] +deps = ["Libdl"] +git-tree-sha1 = "159b1c1f03e6355bb9c6d8954e5f51019788dd26" +registries = "General" +uuid = "1af6417a-86b4-443c-805f-a4643ffb695f" +version = "2.1.1" + +[[deps.CUDA_Runtime_jll]] +deps = ["Artifacts", "CUDA_Compiler_jll", "CUDA_Driver_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "MSVCRuntime_jll", "TOML"] +git-tree-sha1 = "6269b71d191c0081b8fb3ff5945c2a57f16231d4" +registries = "General" +uuid = "76a88914-d11a-5bdc-97e0-2f5a05c973a2" +version = "0.25.0+3" + +[[deps.CUPTI]] +deps = ["CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUToolbox", "Libdl"] +git-tree-sha1 = "8ad5ff580bd0e7455905d3f8eed0c373bd8b2882" +registries = "General" +uuid = "9e67e8f6-ba02-4b6c-a7db-3b11ae1e7ab7" +version = "6.5.1" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerCaching]] +deps = ["LMDB", "SHA", "Scratch"] +git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" +registries = "General" +uuid = "9db33cc3-5358-4881-8759-fa4194144afd" +version = "0.5.3" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CondaPkg]] +deps = ["FileWatching", "JSON", "Markdown", "MicroMamba", "Pkg", "Preferences", "Scratch", "TOML", "pixi_jll"] +git-tree-sha1 = "5105aafa8fedef75ad7f44d7dbf85a1b7196e406" +registries = "General" +uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +version = "0.2.38" + +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + +[[deps.Crayons]] +git-tree-sha1 = "54b76cbb40d9a0f5368c880725b2f141da77c94f" +registries = "General" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.2.0" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +registries = "General" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +registries = "General" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.GPUArrays]] +deps = ["AcceleratedKernels", "Adapt", "GPUArraysCore", "KernelAbstractions", "LLVM", "LinearAlgebra", "Printf", "Random", "Reexport", "ScopedValues", "Serialization", "SparseArrays", "Statistics"] +git-tree-sha1 = "1cd2703c11e873a60d0182b6806217a26d71d252" +registries = "General" +uuid = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" +version = "12.2.0" + + [deps.GPUArrays.extensions] + JLD2Ext = "JLD2" + + [deps.GPUArrays.weakdeps] + JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "f60436514e6d73f8ee069ae4ee0ff038fe96b69d" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.2" + +[[deps.GPUCompiler]] +deps = ["CompilerCaching", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "REPL", "ScopedValues", "TOML", "Tracy", "UUIDs", "tree_sitter_gcn_jll", "tree_sitter_llvm_jll", "tree_sitter_ptx_jll", "tree_sitter_spirv_jll"] +git-tree-sha1 = "65175d8064f99fc7a27cc9b69bed573b35ee080e" +registries = "General" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "2.21.0" + + [deps.GPUCompiler.extensions] + CthulhuExt = "Cthulhu" + HighlightsExt = "Highlights" + + [deps.GPUCompiler.weakdeps] + AMDGPU_LLVM_Backend_jll = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" + Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f" + Highlights = "eafb193a-b7ab-5a9e-9068-77385905fa72" + LLVMDowngrader_jll = "f52de702-fb25-5922-94ba-81dd59b07444" + NVPTX_LLVM_Backend_jll = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" + SPIRV_LLVM_Backend_jll = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" + SPIRV_LLVM_Translator_jll = "4a5d46fc-d8cf-5151-a261-86b458210efb" + +[[deps.GPUToolbox]] +git-tree-sha1 = "a380d7a5bf9be3fb1e85344c683bab446f4861c0" +registries = "General" +uuid = "096a3bc2-3ced-46d0-87f4-dd12716f4bfc" +version = "3.5.1" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +registries = "General" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "06d90f699285d055e34f0b014636a75a17ff2252" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.13.4" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + JSONSerializationExt = ["Serialization"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.JuliaNVTXCallbacks_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "af433a10f3942e882d3c671aacb203e006a5808f" +registries = "General" +uuid = "9c1d0b0a-7046-5b2e-a33f-ea22f176ac7e" +version = "0.2.1+0" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "MacroTools", "PrecompileTools", "Printf", "Random", "Random123", "RandomNumbers", "SPIRVIntrinsics", "SPIRV_LLVM_Backend_jll", "SPIRV_Tools_jll", "StaticArraysCore", "UnsafeAtomics", "pocl_standalone_jll"] +git-tree-sha1 = "0b9e978d21df1aa3ead81c89a2bdf3c6f063a39c" +registries = "General" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.10.5" + + [deps.KernelAbstractions.extensions] + AMDGPUExt = "AMDGPU" + LinearAlgebraExt = "LinearAlgebra" + MetalExt = "Metal" + SparseArraysExt = "SparseArrays" + StaticArraysExt = "StaticArrays" + oneAPIExt = "oneAPI" + + [deps.KernelAbstractions.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.KernelInterface]] +git-tree-sha1 = "62300ced3fd046f4694e8dbf0e2fbc2bed84f371" +registries = "General" +uuid = "4ee993da-d684-4d17-a7dd-4e58e78d92bf" +version = "0.4.5" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "PrecompileTools", "Preferences", "Printf", "ScopedValues", "Unicode"] +git-tree-sha1 = "41c2ce7ec5a14c89b93dc6a5853bf2a91d7a8583" +registries = "General" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "10.4.3" +weakdeps = ["BFloat16s"] + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "39def0b4521e0ef2bf26960d8965729f496bb4ec" +registries = "General" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.56+0" + +[[deps.LLVMLoopInfo]] +git-tree-sha1 = "2e5c102cfc41f48ae4740c7eca7743cc7e7b75ea" +registries = "General" +uuid = "8b046642-f1f6-4319-8d3c-209ddc03c586" +version = "1.0.0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LMDB]] +deps = ["CEnum", "LMDB_jll"] +git-tree-sha1 = "84e5cba87693714bfd67f589a91f24a996ff3e69" +registries = "General" +uuid = "11f193de-5e89-5f17-923a-7d207d56daf9" +version = "3.0.1" + +[[deps.LMDB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "196c962b4d66b978b9be1e15e4e1d53441d5f028" +registries = "General" +uuid = "6206cf0b-f360-5984-af49-5437264c140e" +version = "1.0.3+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "f88f3ccef05a6a72a0cf0ed417c8fd68530f4ab2" +registries = "General" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.1" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +registries = "General" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MSVCRuntime_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "9670d7b2dbc92652a250e88eaa80861892d453e2" +registries = "General" +uuid = "ce32ce21-2cee-52aa-a084-5c6dad4fa7db" +version = "14.51.36247+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MicroMamba]] +deps = ["Pkg", "Scratch", "micromamba_jll"] +git-tree-sha1 = "535656ce55266bfed0575cd051acc4f36dc869a0" +registries = "General" +uuid = "0b3b1443-0f03-428d-bdfb-f27f9c1191ea" +version = "0.1.15" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.NVML]] +deps = ["CEnum", "CUDACore", "GPUToolbox", "Libdl"] +git-tree-sha1 = "75532531b1af772ab58b7ad513fe086aecb82e0a" +registries = "General" +uuid = "611af6d1-644e-4c5d-bd58-854d7d1254b9" +version = "6.5.1" + +[[deps.NVPTX_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "839f120ee970f8216f91034ce8e0436bf5b04ce3" +registries = "General" +uuid = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" +version = "23.1.2+2" + +[[deps.NVTX]] +deps = ["JuliaNVTXCallbacks_jll", "Libdl", "NVTX_jll"] +git-tree-sha1 = "a9083c3e469e63cca454d1fc3b19472d9d92c14a" +registries = "General" +uuid = "5da4648a-3479-48b8-97b9-01cb529c0a1f" +version = "1.0.3" + + [deps.NVTX.extensions] + NVTXColorsExt = "Colors" + + [deps.NVTX.weakdeps] + Colors = "5ae59095-9a9b-59fe-a467-6f913c188581" + +[[deps.NVTX_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "af2232f69447494514c25742ba1503ec7e9877fe" +registries = "General" +uuid = "e98f9f5b-d649-5603-91fd-7774390e6439" +version = "3.2.2+0" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "b079a6affebde167dad8ffe0d670b53917fbcb68" +registries = "General" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "2.0.3" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools"] +git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "3.0.6" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "REPL", "Reexport", "StringManipulation", "StyledStrings", "Tables"] +git-tree-sha1 = "eeac4c9337f876c3c32b8da732141953567f57c9" +registries = "General" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "3.5.1" + + [deps.PrettyTables.extensions] + PrettyTablesExcelExt = "XLSX" + PrettyTablesTypstryExt = "Typstry" + PrettyTablesWriteDocxExt = "WriteDocx" + + [deps.PrettyTables.weakdeps] + Typstry = "f0ed7684-a786-439e-b1e3-3b82803b501e" + WriteDocx = "d049ceea-54ee-41d7-a26f-ba29db3b6599" + XLSX = "fdbf4ff8-1666-58a4-91e7-1b58723a45e0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PythonCall]] +deps = ["CondaPkg", "Dates", "Libdl", "MacroTools", "Markdown", "Preferences", "Serialization", "Tables", "UnsafePointers"] +git-tree-sha1 = "00d3a883b716a8482da76d08dae1f6084bbfeb23" +registries = "General" +uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +version = "0.9.37" + + [deps.PythonCall.extensions] + CategoricalArraysExt = "CategoricalArrays" + PyCallExt = "PyCall" + + [deps.PythonCall.weakdeps] + CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +registries = "General" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +registries = "General" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEF_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" +registries = "General" +uuid = "63e82ce6-3d80-5af4-a84c-484b71ab98bb" +version = "3.9.0+2" + +[[deps.SPIRVIntrinsics]] +deps = ["GPUToolbox", "LLVM", "UnsafeAtomics"] +git-tree-sha1 = "2ee2b6f667d53d1f03079ce7179f7de7ef5058b7" +registries = "General" +uuid = "71d1d633-e7e8-4a92-83a1-de8814b09ba8" +version = "1.6.0" + + [deps.SPIRVIntrinsics.extensions] + SPIRVIntrinsicsSIMDExt = "SIMD" + SPIRVIntrinsicsSIMDSpecialFunctionsExt = ["SIMD", "SpecialFunctions"] + SPIRVIntrinsicsSpecialFunctionsExt = "SpecialFunctions" + + [deps.SPIRVIntrinsics.weakdeps] + GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55" + SIMD = "fdea26ae-647d-5447-a871-4b548cad5224" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SPIRV_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "6aaddfdf3040d02a5b3e10c6cd0e4e1dce27f23c" +registries = "General" +uuid = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" +version = "23.1.4+1" + +[[deps.SPIRV_Tools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "783c358eff59056d7e703a644f5179270c43226a" +registries = "General" +uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" +version = "2025.4.0+0" + +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SolpropJulia]] +deps = ["AcceleratedKernels", "Atomix", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] +path = ".." +uuid = "bc9db228-6fd1-46b1-b175-748485922872" +version = "0.0.0" + + [deps.SolpropJulia.extensions] + SolpropJuliaAMDGPUExt = "AMDGPU" + SolpropJuliaCUDAExt = "CUDA" + + [deps.SolpropJulia.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.13.0" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "e2b53ce13a53367e96601081e33d34746b571bad" +registries = "General" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.5" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + +[[deps.StringManipulation]] +deps = ["PrecompileTools", "StyledStrings"] +git-tree-sha1 = "9e3a02d73a8f0a9be04e677dbef758aab40f8bea" +registries = "General" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.6.1" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" +registries = "General" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.12.0" + + [deps.StructUtils.extensions] + StructUtilsDBInterfaceExt = ["DBInterface", "Tables"] + StructUtilsDataFramesExt = ["DataFrames"] + StructUtilsLazilyInitializedFieldsExt = ["LazilyInitializedFields"] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazilyInitializedFields = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.10.1+0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +registries = "General" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "a94d9bdda1b7bed0046cea645639ab3f62196fac" +registries = "General" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.14.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +registries = "General" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +deps = ["LLVM"] +git-tree-sha1 = "74ac5e0e702972da953ffc981094617070be582d" +registries = "General" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.4.0" +weakdeps = ["GPUCompiler"] + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsGPUCompilerExt = "GPUCompiler" + +[[deps.UnsafePointers]] +git-tree-sha1 = "c81331b3b2e60a982be57c046ec91f599ede674a" +registries = "General" +uuid = "e17b2a0c-0bdf-430a-bd0c-3a23cae4ff39" +version = "1.0.0" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.cuBLAS]] +deps = ["Adapt", "BFloat16s", "CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUArrays", "GPUToolbox", "LLVM", "LinearAlgebra"] +git-tree-sha1 = "4a182d7bc3a87868d963eeeb12277cb8a825eaea" +registries = "General" +uuid = "182d3088-87b7-4494-8cad-fc6afaa545bc" +version = "6.5.1" + + [deps.cuBLAS.extensions] + EnzymeCoreExt = "EnzymeCore" + + [deps.cuBLAS.weakdeps] + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + +[[deps.cuFFT]] +deps = ["AbstractFFTs", "CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUToolbox", "LinearAlgebra", "Reexport"] +git-tree-sha1 = "275873c4d33d11b2df748c3f3458ab1f1b21eddb" +registries = "General" +uuid = "533571aa-0936-420e-b4be-9c66f5f626ca" +version = "6.5.1" + +[[deps.cuRAND]] +deps = ["CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUToolbox", "Random", "Random123", "RandomNumbers"] +git-tree-sha1 = "20b8515e542b3dd01beb5dd69ca685531274ff68" +registries = "General" +uuid = "20fd9a0b-12d5-4c2f-a8af-7c34e9e60431" +version = "6.5.1" + +[[deps.cuSOLVER]] +deps = ["CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUToolbox", "LinearAlgebra", "SparseArrays", "cuBLAS", "cuSPARSE"] +git-tree-sha1 = "9a985ead9bf3314add409c2ff2652d1317e0851f" +registries = "General" +uuid = "887afef0-6a32-4de5-add4-7827692ba8fc" +version = "6.5.1" + +[[deps.cuSPARSE]] +deps = ["Adapt", "CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUArrays", "GPUToolbox", "KernelInterface", "LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "025dfe67c4257440206ed720ea5445ed5336d425" +registries = "General" +uuid = "b26da814-b3bc-49ef-b0ee-c816305aa060" +version = "6.5.1" + + [deps.cuSPARSE.extensions] + SparseMatricesCSRExt = "SparseMatricesCSR" + + [deps.cuSPARSE.weakdeps] + SparseMatricesCSR = "a0a7dd2c-ebf4-11e9-1f05-cf50bc540ca1" + +[[deps.demumble_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6498e3581023f8e530f34760d18f75a69e3a4ea8" +registries = "General" +uuid = "1e29f10c-031c-5a83-9565-69cddfc27673" +version = "1.3.0+0" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.micromamba_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "717df6f6892af4ee13279a73aa58474e58a88667" +registries = "General" +uuid = "f8abcde7-e9b7-5caa-b8af-a437887ae8e4" +version = "2.3.1+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + +[[deps.pixi_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "56c56fede8f01e1be7e2fdf1eb911487640619a0" +registries = "General" +uuid = "4d7b5844-a134-5dcd-ac86-c8f19cd51bed" +version = "0.76.2+0" + +[[deps.pocl_standalone_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] +git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" +registries = "General" +uuid = "54f56a70-6062-5590-a942-1226658f6c83" +version = "7.2.3+7" + +[[deps.tree_sitter_gcn_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7aea9f731552967bda93cb7cbf6925de65bc38d5" +registries = "General" +uuid = "8b5cbfcf-8811-596e-8e87-0e51e05ee4b2" +version = "0.1.0+0" + +[[deps.tree_sitter_llvm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2fb7d0e3a8abf532fa922766ca130bf814df1e70" +registries = "General" +uuid = "44208993-ee63-5069-9443-8e43b04a9b30" +version = "1.1.0+0" + +[[deps.tree_sitter_ptx_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e6ad264eebe3e34f03bca6b5e811d80e0f4797a2" +registries = "General" +uuid = "71e3f6e6-c059-5e7c-a2f2-d560fdad7ce5" +version = "0.1.0+0" + +[[deps.tree_sitter_spirv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7d8c03949bab84b23fe0500d89979e786d54a653" +registries = "General" +uuid = "f0e86581-c468-54df-a4de-3266e11a3c86" +version = "0.1.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/julia/cuda/Project.toml b/julia/cuda/Project.toml new file mode 100644 index 000000000..3cd905bc9 --- /dev/null +++ b/julia/cuda/Project.toml @@ -0,0 +1,10 @@ +[deps] +CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +SolpropJulia = "bc9db228-6fd1-46b1-b175-748485922872" + +[sources] +SolpropJulia = {path = ".."} + +[extras] +CUDA_Runtime_jll = "76a88914-d11a-5bdc-97e0-2f5a05c973a2" diff --git a/julia/ext/SolpropJuliaAMDGPUExt.jl b/julia/ext/SolpropJuliaAMDGPUExt.jl new file mode 100644 index 000000000..aff469e44 --- /dev/null +++ b/julia/ext/SolpropJuliaAMDGPUExt.jl @@ -0,0 +1,13 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# AMD GPUs: the engine's arrays become ROCArrays, its transforms rocFFT plans and its +# products rocBLAS calls; every pass is the same scalar body as on a CPU or an NVIDIA GPU. +module SolpropJuliaAMDGPUExt +using AMDGPU +import SolpropJulia + +SolpropJulia.device_backend(::Val{:rocm}) = (AMDGPU.allowscalar(false); ROCBackend()) +SolpropJulia.device_label(::ROCBackend) = "rocm: " * string(AMDGPU.device()) + +end diff --git a/julia/ext/SolpropJuliaCUDAExt.jl b/julia/ext/SolpropJuliaCUDAExt.jl new file mode 100644 index 000000000..d7c0d54de --- /dev/null +++ b/julia/ext/SolpropJuliaCUDAExt.jl @@ -0,0 +1,23 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# NVIDIA GPUs: the engine's arrays become CuArrays, its transforms cuFFT plans and its +# products cuBLAS calls; every pass is the same scalar body as on a CPU. +module SolpropJuliaCUDAExt +using CUDA +import SolpropJulia + +SolpropJulia.device_backend(::Val{:cuda}) = (CUDA.allowscalar(false); CUDABackend()) +SolpropJulia.device_label(::CUDABackend) = "cuda: " * CUDA.name(CUDA.device()) +# cuFFT's binary64 transforms of a few thousand points run one block a transform +# (96 us at 5120 on an A40): the engine splits them (`LongFFT`). +SolpropJulia.long_transforms(::CUDABackend) = true +# cuFFT's strided transverse planes are 3.4 times contiguous ones (`Transposed`). +SolpropJulia.transposed_planes(::CUDABackend) = true +# A source's passes as a CUDA graph (`graph_source!`): stream capture records them, +# kernels, cuFFT and cuBLAS alike, on the task's stream. +SolpropJulia.graph_capable(::CUDABackend) = true +SolpropJulia.graph_capture(::CUDABackend, f) = CUDA.instantiate(CUDA.capture(f)) +SolpropJulia.graph_launch(exec::CUDA.CuGraphExec) = CUDA.launch(exec) + +end diff --git a/julia/ext/SolpropJuliaMetalExt.jl b/julia/ext/SolpropJuliaMetalExt.jl new file mode 100644 index 000000000..8922bad13 --- /dev/null +++ b/julia/ext/SolpropJuliaMetalExt.jl @@ -0,0 +1,15 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Apple GPUs: the engine's arrays become MtlArrays, its transforms MPSGraph plans and +# its products Metal.jl's; every pass is the same scalar body as on a CPU. Metal has no +# binary64: the engine runs binary32 with the operator's exponents and the Adams flow +# in double-float (dfloat.jl), and refuses anything else at construction. +module SolpropJuliaMetalExt +using Metal +import SolpropJulia + +SolpropJulia.device_backend(::Val{:metal}) = (Metal.allowscalar(false); MetalBackend()) +SolpropJulia.device_label(::MetalBackend) = "metal: " * String(Metal.device().name) + +end diff --git a/julia/metal/LocalPreferences.toml b/julia/metal/LocalPreferences.toml new file mode 100644 index 000000000..4823a80ac --- /dev/null +++ b/julia/metal/LocalPreferences.toml @@ -0,0 +1,3 @@ +# Private GPU storage: a host scalar access is then an error, not a silent slow path. +[Metal] +default_storage = "private" diff --git a/julia/metal/Manifest.toml b/julia/metal/Manifest.toml new file mode 100644 index 000000000..3dae00b7e --- /dev/null +++ b/julia/metal/Manifest.toml @@ -0,0 +1,1074 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "bec50a54d02cbc4fbe06376862b2fccbf112cb33" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.AcceleratedKernels]] +deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] +git-tree-sha1 = "ac481710a9eee43b1d8dbd1e26a49a19de71475a" +registries = "General" +uuid = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +version = "0.5.11" + + [deps.AcceleratedKernels.extensions] + CUDACoreExt = "CUDACore" + MetalExt = "Metal" + OpenCLExt = "OpenCL" + oneAPIExt = "oneAPI" + + [deps.AcceleratedKernels.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "eec8a0ad4e4b673afba213931504c360fffb8f97" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.8.0" + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + + [deps.Adapt.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +registries = "General" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "0aa371c875e24cf773c87b2f50ab03e4545748af" +registries = "General" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.7.0" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + +[[deps.BFloat16s]] +deps = ["LinearAlgebra", "Printf", "Random"] +git-tree-sha1 = "59ba860cf4d7e2fe58f35c8d08cfe765b6c33655" +registries = "General" +uuid = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" +version = "0.6.5" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.Bzip2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1b96ea4a01afe0ea4090c5c8039690672dd13f2e" +registries = "General" +uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" +version = "1.0.9+0" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +registries = "General" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CodecBzip2]] +deps = ["Bzip2_jll", "TranscodingStreams"] +git-tree-sha1 = "84990fa864b7f2b4901901ca12736e45ee79068c" +registries = "General" +uuid = "523fee87-0ab8-5b00-afb7-3ecf72e48cfd" +version = "0.8.5" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerCaching]] +deps = ["LMDB", "SHA", "Scratch"] +git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" +registries = "General" +uuid = "9db33cc3-5358-4881-8759-fa4194144afd" +version = "0.5.3" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CondaPkg]] +deps = ["FileWatching", "JSON", "Markdown", "MicroMamba", "Pkg", "Preferences", "Scratch", "TOML", "pixi_jll"] +git-tree-sha1 = "5105aafa8fedef75ad7f44d7dbf85a1b7196e406" +registries = "General" +uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +version = "0.2.38" + +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + +[[deps.Crayons]] +git-tree-sha1 = "54b76cbb40d9a0f5368c880725b2f141da77c94f" +registries = "General" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.2.0" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +registries = "General" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +registries = "General" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.GPUArrays]] +deps = ["AcceleratedKernels", "Adapt", "GPUArraysCore", "KernelAbstractions", "LLVM", "LinearAlgebra", "Printf", "Random", "Reexport", "ScopedValues", "Serialization", "SparseArrays", "Statistics"] +git-tree-sha1 = "1cd2703c11e873a60d0182b6806217a26d71d252" +registries = "General" +uuid = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" +version = "12.2.0" + + [deps.GPUArrays.extensions] + JLD2Ext = "JLD2" + + [deps.GPUArrays.weakdeps] + JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "f60436514e6d73f8ee069ae4ee0ff038fe96b69d" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.2" + +[[deps.GPUCompiler]] +deps = ["CompilerCaching", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "REPL", "ScopedValues", "TOML", "Tracy", "UUIDs", "tree_sitter_gcn_jll", "tree_sitter_llvm_jll", "tree_sitter_ptx_jll", "tree_sitter_spirv_jll"] +git-tree-sha1 = "65175d8064f99fc7a27cc9b69bed573b35ee080e" +registries = "General" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "2.21.0" + + [deps.GPUCompiler.extensions] + CthulhuExt = "Cthulhu" + HighlightsExt = "Highlights" + + [deps.GPUCompiler.weakdeps] + AMDGPU_LLVM_Backend_jll = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" + Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f" + Highlights = "eafb193a-b7ab-5a9e-9068-77385905fa72" + LLVMDowngrader_jll = "f52de702-fb25-5922-94ba-81dd59b07444" + NVPTX_LLVM_Backend_jll = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" + SPIRV_LLVM_Backend_jll = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" + SPIRV_LLVM_Translator_jll = "4a5d46fc-d8cf-5151-a261-86b458210efb" + +[[deps.GPUToolbox]] +git-tree-sha1 = "a380d7a5bf9be3fb1e85344c683bab446f4861c0" +registries = "General" +uuid = "096a3bc2-3ced-46d0-87f4-dd12716f4bfc" +version = "3.5.1" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +registries = "General" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "06d90f699285d055e34f0b014636a75a17ff2252" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.13.4" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + JSONSerializationExt = ["Serialization"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "MacroTools", "PrecompileTools", "Printf", "Random", "Random123", "RandomNumbers", "SPIRVIntrinsics", "SPIRV_LLVM_Backend_jll", "SPIRV_Tools_jll", "StaticArraysCore", "UnsafeAtomics", "pocl_standalone_jll"] +git-tree-sha1 = "0b9e978d21df1aa3ead81c89a2bdf3c6f063a39c" +registries = "General" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.10.5" + + [deps.KernelAbstractions.extensions] + AMDGPUExt = "AMDGPU" + LinearAlgebraExt = "LinearAlgebra" + MetalExt = "Metal" + SparseArraysExt = "SparseArrays" + StaticArraysExt = "StaticArrays" + oneAPIExt = "oneAPI" + + [deps.KernelAbstractions.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.KernelInterface]] +git-tree-sha1 = "62300ced3fd046f4694e8dbf0e2fbc2bed84f371" +registries = "General" +uuid = "4ee993da-d684-4d17-a7dd-4e58e78d92bf" +version = "0.4.5" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "PrecompileTools", "Preferences", "Printf", "ScopedValues", "Unicode"] +git-tree-sha1 = "41c2ce7ec5a14c89b93dc6a5853bf2a91d7a8583" +registries = "General" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "10.4.3" +weakdeps = ["BFloat16s"] + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + +[[deps.LLVMDowngrader_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "2db47bc5100d848d977608dbf58fb7ceea1ffa4f" +registries = "General" +uuid = "f52de702-fb25-5922-94ba-81dd59b07444" +version = "0.12.2+0" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "39def0b4521e0ef2bf26960d8965729f496bb4ec" +registries = "General" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.56+0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LMDB]] +deps = ["CEnum", "LMDB_jll"] +git-tree-sha1 = "84e5cba87693714bfd67f589a91f24a996ff3e69" +registries = "General" +uuid = "11f193de-5e89-5f17-923a-7d207d56daf9" +version = "3.0.1" + +[[deps.LMDB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "196c962b4d66b978b9be1e15e4e1d53441d5f028" +registries = "General" +uuid = "6206cf0b-f360-5984-af49-5437264c140e" +version = "1.0.3+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "f88f3ccef05a6a72a0cf0ed417c8fd68530f4ab2" +registries = "General" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.1" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +registries = "General" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.Metal]] +deps = ["AbstractFFTs", "Adapt", "BFloat16s", "CEnum", "CodecBzip2", "Crayons", "ExprTools", "GPUArrays", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "LLVMDowngrader_jll", "LinearAlgebra", "ObjectiveC", "PrecompileTools", "Preferences", "PrettyTables", "Printf", "Random", "Random123", "RandomNumbers", "Reexport", "SHA", "ScopedValues", "Statistics", "UUIDs", "UnsafeAtomics"] +git-tree-sha1 = "39e9cec9bc34d25669e34e5cc7cbedb6185445cb" +registries = "General" +uuid = "dde4c033-4e86-420c-a63e-0dd931031962" +version = "1.12.0" + + [deps.Metal.extensions] + KernelAbstractionsExt = "KernelAbstractions" + SpecialFunctionsExt = "SpecialFunctions" + + [deps.Metal.weakdeps] + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.MicroMamba]] +deps = ["Pkg", "Scratch", "micromamba_jll"] +git-tree-sha1 = "535656ce55266bfed0575cd051acc4f36dc869a0" +registries = "General" +uuid = "0b3b1443-0f03-428d-bdfb-f27f9c1191ea" +version = "0.1.15" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.ObjectiveC]] +deps = ["CEnum", "Preferences"] +git-tree-sha1 = "fab69a99a059d433330302c23fe088f808263f7e" +registries = "General" +uuid = "e86c9b32-1129-44ac-8ea0-90d5bb39ded9" +version = "7.2.0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "b079a6affebde167dad8ffe0d670b53917fbcb68" +registries = "General" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "2.0.3" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools"] +git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "3.0.6" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "REPL", "Reexport", "StringManipulation", "StyledStrings", "Tables"] +git-tree-sha1 = "eeac4c9337f876c3c32b8da732141953567f57c9" +registries = "General" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "3.5.1" + + [deps.PrettyTables.extensions] + PrettyTablesExcelExt = "XLSX" + PrettyTablesTypstryExt = "Typstry" + PrettyTablesWriteDocxExt = "WriteDocx" + + [deps.PrettyTables.weakdeps] + Typstry = "f0ed7684-a786-439e-b1e3-3b82803b501e" + WriteDocx = "d049ceea-54ee-41d7-a26f-ba29db3b6599" + XLSX = "fdbf4ff8-1666-58a4-91e7-1b58723a45e0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PythonCall]] +deps = ["CondaPkg", "Dates", "Libdl", "MacroTools", "Markdown", "Preferences", "Serialization", "Tables", "UnsafePointers"] +git-tree-sha1 = "00d3a883b716a8482da76d08dae1f6084bbfeb23" +registries = "General" +uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +version = "0.9.37" + + [deps.PythonCall.extensions] + CategoricalArraysExt = "CategoricalArrays" + PyCallExt = "PyCall" + + [deps.PythonCall.weakdeps] + CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +registries = "General" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +registries = "General" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEF_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" +registries = "General" +uuid = "63e82ce6-3d80-5af4-a84c-484b71ab98bb" +version = "3.9.0+2" + +[[deps.SPIRVIntrinsics]] +deps = ["GPUToolbox", "LLVM", "UnsafeAtomics"] +git-tree-sha1 = "2ee2b6f667d53d1f03079ce7179f7de7ef5058b7" +registries = "General" +uuid = "71d1d633-e7e8-4a92-83a1-de8814b09ba8" +version = "1.6.0" + + [deps.SPIRVIntrinsics.extensions] + SPIRVIntrinsicsSIMDExt = "SIMD" + SPIRVIntrinsicsSIMDSpecialFunctionsExt = ["SIMD", "SpecialFunctions"] + SPIRVIntrinsicsSpecialFunctionsExt = "SpecialFunctions" + + [deps.SPIRVIntrinsics.weakdeps] + GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55" + SIMD = "fdea26ae-647d-5447-a871-4b548cad5224" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SPIRV_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "bbcf46bb8f27f70a2601630c03be93398ab83f7e" +registries = "General" +uuid = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" +version = "23.1.4+2" + +[[deps.SPIRV_Tools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "783c358eff59056d7e703a644f5179270c43226a" +registries = "General" +uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" +version = "2025.4.0+0" + +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SolpropJulia]] +deps = ["AcceleratedKernels", "Atomix", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] +path = ".." +uuid = "bc9db228-6fd1-46b1-b175-748485922872" +version = "0.0.0" + + [deps.SolpropJulia.extensions] + SolpropJuliaAMDGPUExt = "AMDGPU" + SolpropJuliaCUDAExt = "CUDA" + SolpropJuliaMetalExt = "Metal" + + [deps.SolpropJulia.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.13.0" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "e2b53ce13a53367e96601081e33d34746b571bad" +registries = "General" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.5" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + +[[deps.StringManipulation]] +deps = ["PrecompileTools", "StyledStrings"] +git-tree-sha1 = "9e3a02d73a8f0a9be04e677dbef758aab40f8bea" +registries = "General" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.6.1" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" +registries = "General" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.12.0" + + [deps.StructUtils.extensions] + StructUtilsDBInterfaceExt = ["DBInterface", "Tables"] + StructUtilsDataFramesExt = ["DataFrames"] + StructUtilsLazilyInitializedFieldsExt = ["LazilyInitializedFields"] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazilyInitializedFields = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.10.1+0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +registries = "General" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "a94d9bdda1b7bed0046cea645639ab3f62196fac" +registries = "General" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.14.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +registries = "General" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.TranscodingStreams]] +git-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742" +registries = "General" +uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" +version = "0.11.3" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +deps = ["LLVM"] +git-tree-sha1 = "74ac5e0e702972da953ffc981094617070be582d" +registries = "General" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.4.0" +weakdeps = ["GPUCompiler"] + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsGPUCompilerExt = "GPUCompiler" + +[[deps.UnsafePointers]] +git-tree-sha1 = "c81331b3b2e60a982be57c046ec91f599ede674a" +registries = "General" +uuid = "e17b2a0c-0bdf-430a-bd0c-3a23cae4ff39" +version = "1.0.0" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.micromamba_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "717df6f6892af4ee13279a73aa58474e58a88667" +registries = "General" +uuid = "f8abcde7-e9b7-5caa-b8af-a437887ae8e4" +version = "2.3.1+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + +[[deps.pixi_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "56c56fede8f01e1be7e2fdf1eb911487640619a0" +registries = "General" +uuid = "4d7b5844-a134-5dcd-ac86-c8f19cd51bed" +version = "0.76.2+0" + +[[deps.pocl_standalone_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] +git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" +registries = "General" +uuid = "54f56a70-6062-5590-a942-1226658f6c83" +version = "7.2.3+7" + +[[deps.tree_sitter_gcn_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7aea9f731552967bda93cb7cbf6925de65bc38d5" +registries = "General" +uuid = "8b5cbfcf-8811-596e-8e87-0e51e05ee4b2" +version = "0.1.0+0" + +[[deps.tree_sitter_llvm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2fb7d0e3a8abf532fa922766ca130bf814df1e70" +registries = "General" +uuid = "44208993-ee63-5069-9443-8e43b04a9b30" +version = "1.1.0+0" + +[[deps.tree_sitter_ptx_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e6ad264eebe3e34f03bca6b5e811d80e0f4797a2" +registries = "General" +uuid = "71e3f6e6-c059-5e7c-a2f2-d560fdad7ce5" +version = "0.1.0+0" + +[[deps.tree_sitter_spirv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7d8c03949bab84b23fe0500d89979e786d54a653" +registries = "General" +uuid = "f0e86581-c468-54df-a4de-3266e11a3c86" +version = "0.1.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/julia/metal/Project.toml b/julia/metal/Project.toml new file mode 100644 index 000000000..14ccc798e --- /dev/null +++ b/julia/metal/Project.toml @@ -0,0 +1,7 @@ +[deps] +Metal = "dde4c033-4e86-420c-a63e-0dd931031962" +PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +SolpropJulia = "bc9db228-6fd1-46b1-b175-748485922872" + +[sources] +SolpropJulia = {path = ".."} diff --git a/julia/profile.py b/julia/profile.py new file mode 100644 index 000000000..f8d13bbb8 --- /dev/null +++ b/julia/profile.py @@ -0,0 +1,141 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Profile the Julia engine on rows of a benchmark plan, as the harness times them. + +``python julia/profile.py PLAN.json ROW...`` builds each matching row's case for the +julia backend and times a complete run (``benchmarks.worker.timed_run``, observations +and the boundary monitor included) after a first, warming one. With +``SOLPROP_JULIA_TIMING=1`` it prints the engine's section timers, synchronised with the +device on a GPU; with ``SOLPROP_JULIA_PROFILE=1`` Julia's sampling profile instead, +which needs ``SOLPROP_JULIA_THREADS=1`` (it crashes when Python owns more threads). +""" + +import json +import os +import sys + +from benchmarks.builders import build +from benchmarks.worker import timed_run + +from solprop.backends import select +from solprop.driver.run import field_retention + + +def profile(row: dict) -> None: + """Time one row's run twice and report the second.""" + configuration = row["configuration"] | {"backend": "julia"} + simulation = build(configuration) + problem = simulation.translate() + engine = select( + "julia", + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + retention = field_retention( + problem, simulation.settings.fields, simulation.settings.field_planes + ) + timed_run(simulation, problem, engine, retention, simulation._boundary_monitor()) + jl = engine._jl + sampling = os.environ.get("SOLPROP_JULIA_PROFILE") == "1" + if sampling: + from juliacall import Main # noqa: PLC0415 - after the runtime starts + + Main.seval("using Profile; Profile.init(n=10^7, delay=0.0005)") + Main.seval("Profile.clear(); Profile.start_timer()") + jl.clear_timings() + jl.clear_counts() + jl.clear_kernel_timings() + # SOLPROP_JULIA_ALLOCS=1: the host's allocations by where they are made (sampled; + # Profile.Allocs uses no signals, which the sampling profile's kill a CUDA process). + allocs = os.environ.get("SOLPROP_JULIA_ALLOCS") == "1" + if allocs: + from juliacall import Main # noqa: PLC0415 - after the runtime starts + + Main.seval("using Profile; Profile.Allocs.clear(); Profile.Allocs.start(sample_rate=0.002)") + # SOLPROP_PYTHON_PROFILE=1: the host's Python time too (cProfile, by own time). + python = os.environ.get("SOLPROP_PYTHON_PROFILE") == "1" + if python: + # (This script's directory shadows the standard library's `profile`.) + here = os.path.dirname(os.path.abspath(__file__)) # noqa: PTH100, PTH120 + sys.path[:] = [p for p in sys.path if os.path.abspath(p) != here] # noqa: PTH100 + import cProfile # noqa: PLC0415 + import pstats # noqa: PLC0415 + + profiler = cProfile.Profile() + profiler.enable() + record, _ = timed_run( + simulation, problem, engine, retention, simulation._boundary_monitor() + ) + if python: + profiler.disable() + # SOLPROP_PYTHON_PROFILE_SORT / _FILTER: the order and the file filter (a regex). + order = os.environ.get("SOLPROP_PYTHON_PROFILE_SORT", "cumulative") + pattern = os.environ.get("SOLPROP_PYTHON_PROFILE_FILTER", "julia/_|integrators|_march") + pstats.Stats(profiler, stream=sys.stdout).sort_stats(order).print_stats(pattern, 40) + if sampling: + Main.seval("Profile.stop_timer()") + Main.seval( + "Profile.print(IOContext(stdout, :displaysize => (200, 220)); " + "format=:flat, sortedby=:count, mincount=20, noisefloor=1)" + ) + if allocs: + Main.seval("Profile.Allocs.stop()") + sys.stdout.write(str(Main.seval(r""" + let r = Profile.Allocs.fetch(), sites = Dict{String,Tuple{Int,Int}}() + for a in r.allocs + # The first frame in SolpropJulia, and the frame below it. + i = findfirst(f -> occursin("SolpropJulia", string(f.file)) || + occursin("/julia/src/", string(f.file)), a.stacktrace) + i === nothing && continue + f = a.stacktrace[i] + below = a.stacktrace[max(i - 1, 1)] + key = string(f.func, " ", basename(string(f.file)), ":", f.line, " <- ", + below.func) + n, b = get(sites, key, (0, 0)) + sites[key] = (n + 1, b + a.size) + end + total = length(r.allocs) + lines = ["sampled allocations: $total (x500 for the run)"] + for (k, (n, b)) in sort(collect(sites); by=x -> -x[2][1])[1:min(30, end)] + push!(lines, lpad(n, 7) * lpad(b, 11) * " " * k) + end + join(lines, "\n") + end""")) + "\n") + times = jl.timings() + total = sum(float(times[name]) for name in times) + sys.stdout.write( + f"{row['id']}: {record['seconds']:.3f} s, {record['accepted']} steps, " + f"sections {total:.3f} s\n" + ) + for name in sorted(times, key=lambda n: -float(times[n])): + sys.stdout.write(f" {name:>18} {float(times[name]):8.4f} s\n") + # SOLPROP_JULIA_COUNT=1: the device's launches, waits and allocations a step. + counts = {str(k): int(v) for k, v in jl.counts().items()} + steps = max(int(record["accepted"]), 1) + for name in sorted(counts): + sys.stdout.write(f" {name:>18} {counts[name] / steps:8.1f} a step ({counts[name]})\n") + # SOLPROP_JULIA_KERNEL_TIMING=1: each GPU pass alone, by its body. + kernels = {str(k): list(v) for k, v in jl.kernel_timings().items()} + for name in sorted(kernels, key=lambda n: -float(kernels[n][1]))[:25]: + count, total, size = kernels[name] + sys.stdout.write( + f" {float(total) * 1e3:8.2f} ms {int(count):6d} x {int(size):9d} {name}\n" + ) + engine.close() + + +def main() -> None: + """Profile every row of the plan whose id contains one of the arguments.""" + plan = json.loads(open(sys.argv[1], encoding="utf-8").read()) # noqa: PTH123, SIM115 + for row in plan["rows"]: + if row["configuration"]["backend"] == "native" and any( + name in row["id"] for name in sys.argv[2:] + ): + profile(row) + + +if __name__ == "__main__": + main() diff --git a/julia/rocm/Manifest.toml b/julia/rocm/Manifest.toml new file mode 100644 index 000000000..18a09e28f --- /dev/null +++ b/julia/rocm/Manifest.toml @@ -0,0 +1,1056 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "ca8f3b16813e914ee06733138c49801ce1bb645a" + +[[deps.AMDGPU]] +deps = ["AMDGPU_LLVM_Backend_jll", "AbstractFFTs", "Adapt", "Atomix", "BFloat16s", "CEnum", "GPUArrays", "GPUCompiler", "GPUToolbox", "KernelAbstractions", "KernelInterface", "LLVM", "LLVMDowngrader_jll", "Libdl", "LinearAlgebra", "PrecompileTools", "Preferences", "PrettyTables", "Printf", "Random", "Random123", "RandomNumbers", "Scratch", "SparseArrays", "Statistics", "UnsafeAtomics"] +git-tree-sha1 = "339be76666103bf8a2c7b2dd638a80336e9b1fda" +registries = "General" +uuid = "21141c5a-9bdb-4563-92ae-f87d6854732e" +version = "2.11.0" + + [deps.AMDGPU.extensions] + AMDGPUChainRulesCoreExt = "ChainRulesCore" + AMDGPUEnzymeCoreExt = "EnzymeCore" + AMDGPUSparseMatricesCSRExt = "SparseMatricesCSR" + AMDGPUSpecialFunctionsExt = "SpecialFunctions" + + [deps.AMDGPU.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + SparseMatricesCSR = "a0a7dd2c-ebf4-11e9-1f05-cf50bc540ca1" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.AMDGPU_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "b93538105521d4f4432495c16f4d88b8e071dd23" +registries = "General" +uuid = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" +version = "23.1.3+1" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.AcceleratedKernels]] +deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] +git-tree-sha1 = "ac481710a9eee43b1d8dbd1e26a49a19de71475a" +registries = "General" +uuid = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +version = "0.5.11" + + [deps.AcceleratedKernels.extensions] + CUDACoreExt = "CUDACore" + MetalExt = "Metal" + OpenCLExt = "OpenCL" + oneAPIExt = "oneAPI" + + [deps.AcceleratedKernels.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "eec8a0ad4e4b673afba213931504c360fffb8f97" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.8.0" + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + + [deps.Adapt.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +registries = "General" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "0aa371c875e24cf773c87b2f50ab03e4545748af" +registries = "General" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.7.0" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + +[[deps.BFloat16s]] +deps = ["LinearAlgebra", "Printf", "Random"] +git-tree-sha1 = "59ba860cf4d7e2fe58f35c8d08cfe765b6c33655" +registries = "General" +uuid = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" +version = "0.6.5" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +registries = "General" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerCaching]] +deps = ["LMDB", "SHA", "Scratch"] +git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" +registries = "General" +uuid = "9db33cc3-5358-4881-8759-fa4194144afd" +version = "0.5.3" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CondaPkg]] +deps = ["FileWatching", "JSON", "Markdown", "MicroMamba", "Pkg", "Preferences", "Scratch", "TOML", "pixi_jll"] +git-tree-sha1 = "5105aafa8fedef75ad7f44d7dbf85a1b7196e406" +registries = "General" +uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +version = "0.2.38" + +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + +[[deps.Crayons]] +git-tree-sha1 = "54b76cbb40d9a0f5368c880725b2f141da77c94f" +registries = "General" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.2.0" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +registries = "General" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +registries = "General" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.GPUArrays]] +deps = ["AcceleratedKernels", "Adapt", "GPUArraysCore", "KernelAbstractions", "LLVM", "LinearAlgebra", "Printf", "Random", "Reexport", "ScopedValues", "Serialization", "SparseArrays", "Statistics"] +git-tree-sha1 = "1cd2703c11e873a60d0182b6806217a26d71d252" +registries = "General" +uuid = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" +version = "12.2.0" + + [deps.GPUArrays.extensions] + JLD2Ext = "JLD2" + + [deps.GPUArrays.weakdeps] + JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "f60436514e6d73f8ee069ae4ee0ff038fe96b69d" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.2" + +[[deps.GPUCompiler]] +deps = ["CompilerCaching", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "REPL", "ScopedValues", "TOML", "Tracy", "UUIDs", "tree_sitter_gcn_jll", "tree_sitter_llvm_jll", "tree_sitter_ptx_jll", "tree_sitter_spirv_jll"] +git-tree-sha1 = "65175d8064f99fc7a27cc9b69bed573b35ee080e" +registries = "General" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "2.21.0" + + [deps.GPUCompiler.extensions] + CthulhuExt = "Cthulhu" + HighlightsExt = "Highlights" + + [deps.GPUCompiler.weakdeps] + AMDGPU_LLVM_Backend_jll = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" + Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f" + Highlights = "eafb193a-b7ab-5a9e-9068-77385905fa72" + LLVMDowngrader_jll = "f52de702-fb25-5922-94ba-81dd59b07444" + NVPTX_LLVM_Backend_jll = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" + SPIRV_LLVM_Backend_jll = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" + SPIRV_LLVM_Translator_jll = "4a5d46fc-d8cf-5151-a261-86b458210efb" + +[[deps.GPUToolbox]] +git-tree-sha1 = "a380d7a5bf9be3fb1e85344c683bab446f4861c0" +registries = "General" +uuid = "096a3bc2-3ced-46d0-87f4-dd12716f4bfc" +version = "3.5.1" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +registries = "General" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "06d90f699285d055e34f0b014636a75a17ff2252" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.13.4" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + JSONSerializationExt = ["Serialization"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "MacroTools", "PrecompileTools", "Printf", "Random", "Random123", "RandomNumbers", "SPIRVIntrinsics", "SPIRV_LLVM_Backend_jll", "SPIRV_Tools_jll", "StaticArraysCore", "UnsafeAtomics", "pocl_standalone_jll"] +git-tree-sha1 = "0b9e978d21df1aa3ead81c89a2bdf3c6f063a39c" +registries = "General" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.10.5" + + [deps.KernelAbstractions.extensions] + AMDGPUExt = "AMDGPU" + LinearAlgebraExt = "LinearAlgebra" + MetalExt = "Metal" + SparseArraysExt = "SparseArrays" + StaticArraysExt = "StaticArrays" + oneAPIExt = "oneAPI" + + [deps.KernelAbstractions.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.KernelInterface]] +git-tree-sha1 = "62300ced3fd046f4694e8dbf0e2fbc2bed84f371" +registries = "General" +uuid = "4ee993da-d684-4d17-a7dd-4e58e78d92bf" +version = "0.4.5" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "PrecompileTools", "Preferences", "Printf", "ScopedValues", "Unicode"] +git-tree-sha1 = "41c2ce7ec5a14c89b93dc6a5853bf2a91d7a8583" +registries = "General" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "10.4.3" +weakdeps = ["BFloat16s"] + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + +[[deps.LLVMDowngrader_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "2db47bc5100d848d977608dbf58fb7ceea1ffa4f" +registries = "General" +uuid = "f52de702-fb25-5922-94ba-81dd59b07444" +version = "0.12.2+0" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "39def0b4521e0ef2bf26960d8965729f496bb4ec" +registries = "General" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.56+0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LMDB]] +deps = ["CEnum", "LMDB_jll"] +git-tree-sha1 = "84e5cba87693714bfd67f589a91f24a996ff3e69" +registries = "General" +uuid = "11f193de-5e89-5f17-923a-7d207d56daf9" +version = "3.0.1" + +[[deps.LMDB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "196c962b4d66b978b9be1e15e4e1d53441d5f028" +registries = "General" +uuid = "6206cf0b-f360-5984-af49-5437264c140e" +version = "1.0.3+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "f88f3ccef05a6a72a0cf0ed417c8fd68530f4ab2" +registries = "General" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.1" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +registries = "General" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MicroMamba]] +deps = ["Pkg", "Scratch", "micromamba_jll"] +git-tree-sha1 = "535656ce55266bfed0575cd051acc4f36dc869a0" +registries = "General" +uuid = "0b3b1443-0f03-428d-bdfb-f27f9c1191ea" +version = "0.1.15" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "b079a6affebde167dad8ffe0d670b53917fbcb68" +registries = "General" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "2.0.3" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools"] +git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "3.0.6" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "REPL", "Reexport", "StringManipulation", "StyledStrings", "Tables"] +git-tree-sha1 = "eeac4c9337f876c3c32b8da732141953567f57c9" +registries = "General" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "3.5.1" + + [deps.PrettyTables.extensions] + PrettyTablesExcelExt = "XLSX" + PrettyTablesTypstryExt = "Typstry" + PrettyTablesWriteDocxExt = "WriteDocx" + + [deps.PrettyTables.weakdeps] + Typstry = "f0ed7684-a786-439e-b1e3-3b82803b501e" + WriteDocx = "d049ceea-54ee-41d7-a26f-ba29db3b6599" + XLSX = "fdbf4ff8-1666-58a4-91e7-1b58723a45e0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PythonCall]] +deps = ["CondaPkg", "Dates", "Libdl", "MacroTools", "Markdown", "Preferences", "Serialization", "Tables", "UnsafePointers"] +git-tree-sha1 = "00d3a883b716a8482da76d08dae1f6084bbfeb23" +registries = "General" +uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +version = "0.9.37" + + [deps.PythonCall.extensions] + CategoricalArraysExt = "CategoricalArrays" + PyCallExt = "PyCall" + + [deps.PythonCall.weakdeps] + CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +registries = "General" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +registries = "General" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEF_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" +registries = "General" +uuid = "63e82ce6-3d80-5af4-a84c-484b71ab98bb" +version = "3.9.0+2" + +[[deps.SPIRVIntrinsics]] +deps = ["GPUToolbox", "LLVM", "UnsafeAtomics"] +git-tree-sha1 = "2ee2b6f667d53d1f03079ce7179f7de7ef5058b7" +registries = "General" +uuid = "71d1d633-e7e8-4a92-83a1-de8814b09ba8" +version = "1.6.0" + + [deps.SPIRVIntrinsics.extensions] + SPIRVIntrinsicsSIMDExt = "SIMD" + SPIRVIntrinsicsSIMDSpecialFunctionsExt = ["SIMD", "SpecialFunctions"] + SPIRVIntrinsicsSpecialFunctionsExt = "SpecialFunctions" + + [deps.SPIRVIntrinsics.weakdeps] + GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55" + SIMD = "fdea26ae-647d-5447-a871-4b548cad5224" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SPIRV_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "6aaddfdf3040d02a5b3e10c6cd0e4e1dce27f23c" +registries = "General" +uuid = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" +version = "23.1.4+1" + +[[deps.SPIRV_Tools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "783c358eff59056d7e703a644f5179270c43226a" +registries = "General" +uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" +version = "2025.4.0+0" + +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SolpropJulia]] +deps = ["AcceleratedKernels", "Atomix", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] +path = ".." +uuid = "bc9db228-6fd1-46b1-b175-748485922872" +version = "0.0.0" + + [deps.SolpropJulia.extensions] + SolpropJuliaAMDGPUExt = "AMDGPU" + SolpropJuliaCUDAExt = "CUDA" + + [deps.SolpropJulia.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.13.0" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "e2b53ce13a53367e96601081e33d34746b571bad" +registries = "General" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.5" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + +[[deps.StringManipulation]] +deps = ["PrecompileTools", "StyledStrings"] +git-tree-sha1 = "9e3a02d73a8f0a9be04e677dbef758aab40f8bea" +registries = "General" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.6.1" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" +registries = "General" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.12.0" + + [deps.StructUtils.extensions] + StructUtilsDBInterfaceExt = ["DBInterface", "Tables"] + StructUtilsDataFramesExt = ["DataFrames"] + StructUtilsLazilyInitializedFieldsExt = ["LazilyInitializedFields"] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazilyInitializedFields = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.10.1+0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +registries = "General" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "a94d9bdda1b7bed0046cea645639ab3f62196fac" +registries = "General" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.14.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +registries = "General" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +deps = ["LLVM"] +git-tree-sha1 = "74ac5e0e702972da953ffc981094617070be582d" +registries = "General" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.4.0" +weakdeps = ["GPUCompiler"] + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsGPUCompilerExt = "GPUCompiler" + +[[deps.UnsafePointers]] +git-tree-sha1 = "c81331b3b2e60a982be57c046ec91f599ede674a" +registries = "General" +uuid = "e17b2a0c-0bdf-430a-bd0c-3a23cae4ff39" +version = "1.0.0" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.micromamba_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "717df6f6892af4ee13279a73aa58474e58a88667" +registries = "General" +uuid = "f8abcde7-e9b7-5caa-b8af-a437887ae8e4" +version = "2.3.1+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + +[[deps.pixi_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "56c56fede8f01e1be7e2fdf1eb911487640619a0" +registries = "General" +uuid = "4d7b5844-a134-5dcd-ac86-c8f19cd51bed" +version = "0.76.2+0" + +[[deps.pocl_standalone_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] +git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" +registries = "General" +uuid = "54f56a70-6062-5590-a942-1226658f6c83" +version = "7.2.3+7" + +[[deps.tree_sitter_gcn_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7aea9f731552967bda93cb7cbf6925de65bc38d5" +registries = "General" +uuid = "8b5cbfcf-8811-596e-8e87-0e51e05ee4b2" +version = "0.1.0+0" + +[[deps.tree_sitter_llvm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2fb7d0e3a8abf532fa922766ca130bf814df1e70" +registries = "General" +uuid = "44208993-ee63-5069-9443-8e43b04a9b30" +version = "1.1.0+0" + +[[deps.tree_sitter_ptx_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e6ad264eebe3e34f03bca6b5e811d80e0f4797a2" +registries = "General" +uuid = "71e3f6e6-c059-5e7c-a2f2-d560fdad7ce5" +version = "0.1.0+0" + +[[deps.tree_sitter_spirv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7d8c03949bab84b23fe0500d89979e786d54a653" +registries = "General" +uuid = "f0e86581-c468-54df-a4de-3266e11a3c86" +version = "0.1.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/julia/rocm/Project.toml b/julia/rocm/Project.toml new file mode 100644 index 000000000..b24348e33 --- /dev/null +++ b/julia/rocm/Project.toml @@ -0,0 +1,7 @@ +[deps] +AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" +PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +SolpropJulia = "bc9db228-6fd1-46b1-b175-748485922872" + +[sources] +SolpropJulia = {path = ".."} diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl new file mode 100644 index 000000000..c005b1a74 --- /dev/null +++ b/julia/src/SolpropJulia.jl @@ -0,0 +1,312 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""The Julia backend experiment's engine. + +One source for every device and precision: the arrays are `Array`s or a GPU array type +(loaded by a package extension), of `Float64` or `Float32`, and every state-sized +operation is a scalar body launched by `each!`, `each_column!` or `reduce_each` +(`launch.jl`). FFTs go through AbstractFFTs plans and contractions through `mul!`, so +FFTW and BLAS on a CPU, cuFFT and cuBLAS on an NVIDIA GPU. A body must capture only +arrays and scalars, never a configuration or workspace: those hold plans and strings, +which a GPU kernel cannot take. +""" +module SolpropJulia +using LinearAlgebra +using FFTW +using PythonCall +using Polyester: @batch +import AcceleratedKernels as AK +import KernelAbstractions as KA +import Atomix + +# The digest of the sources this module was loaded from, set by the Python loader. +const SOURCE_DIGEST = Ref("") +record_digest(digest) = (SOURCE_DIGEST[] = String(digest); nothing) +loaded_digest() = SOURCE_DIGEST[] + +mutable struct Engine{C,W} + config::C + work::W + fsal_valid::Bool + calls::Int + propagator_dz::Float64 + factor::Float64 + # A GPU trial's quadrature alarm, read back with its norms (`alarm_arrays`) and + # handed to the commit that follows, so that the commit waits for nothing. + alarm::Float64 + alarm_ready::Bool + # A tapered guide's scale at the stage, tau(z): the synthesis takes it, the + # projection its reciprocal (`transform.taper_scale`); one without a taper. + taper::Float64 + # Bumped by every write of the state, so that a GPU's host copy is made once a + # state (`copy_state!`): a plane's observation, statistics, monitor and edge each + # asked for it. + version::Int +end + +include("launch.jl") +include("dfloat.jl") +include("vmath.jl") +include("responses.jl") +include("envelope.jl") +include("modal.jl") +include("free.jl") +include("dopri.jl") +include("rk4.jl") +include("adams.jl") +include("helpers.jl") +include("march.jl") +include("stages.jl") +include("observe.jl") + +real_type(engine) = real(eltype(engine.work.y)) + +# Read at load, not at precompilation: a constant would be baked into the cache. +function __init__() + TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") in ("1", "host") + HOST_TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") == "host" + KERNEL_TIMING[] = get(ENV, "SOLPROP_JULIA_KERNEL_TIMING", "0") == "1" + GRAPHS[] = get(ENV, "SOLPROP_JULIA_GRAPH", "1") != "0" + COUNT[] = get(ENV, "SOLPROP_JULIA_COUNT", "0") == "1" + CHECK[] = get(ENV, "SOLPROP_JULIA_CHECK", "0") == "1" + SAMPLE_PLASMA[] = get(ENV, "SOLPROP_JULIA_PLASMA", "columns") == "samples" + nothing +end + +"""Read the shared settings and route to the modal or the free-space engine.""" +function create(input) + host = HostInput(input) + T = host.has("precision") && host.string("precision") == "single" ? Float32 : Float64 + device = host.has("device") ? host.string("device") : "cpu" + backend = device_backend(Val(Symbol(device))) + # The wide type of the operator's exponents and the Adams flow: binary64, or a + # double-float in a binary32 run that asks for it (an Apple GPU has no binary64). + W = wide_type(T, host.has("wide") ? host.string("wide") : "binary64") + device == "metal" && W === Float64 && + throw(ArgumentError("an Apple GPU has no binary64: metal runs single precision with wide = df32")) + # SOLPROP_JULIA_FTZ=1: flush subnormals to zero in the engine's numerical work (an + # experiment; solprop's policy forbids it, #561). + flush_subnormals!(get(ENV, "SOLPROP_JULIA_FTZ", "0") == "1") + # Apple's Accelerate for the products on macOS (SOLPROP_JULIA_BLAS=openblas keeps + # OpenBLAS): radial's window on one M5 Max thread 1.02 s -> 0.60 s, no case slower. + blas = get(ENV, "SOLPROP_JULIA_BLAS", Sys.isapple() ? "accelerate" : "openblas") + blas in ("accelerate", "openblas") || + throw(ArgumentError("SOLPROP_JULIA_BLAS must be accelerate or openblas")) + blas == "accelerate" && use_accelerate!() + # One pool runs everything (launch.jl, `plan`): the libraries' own are single. + FFTW.set_num_threads(1) + BLAS.set_num_threads(1) + c = ( + backend=backend, T=T, wide=zero(W), tasks=host.int("threads"), scratch=Dict{Any,Any}(), + fft_threads=host.int("fft_threads"), + raman_fft_threads=host.has("raman_fft_threads") ? host.int("raman_fft_threads") : host.int("fft_threads"), + transverse_fft_threads=host.has("transverse_fft_threads") ? host.int("transverse_fft_threads") : host.int("fft_threads"), + envelope=host.flag("envelope"), low_storage=host.flag("low_storage"), + free=host.flag("free"), split=host.flag("split"), analytic=host.flag("analytic"), + analytic_factor=T(host.real("analytic_factor")), factor=host.real("factor"), + harmonic=T(host.has("harmonic_factor") ? host.real("harmonic_factor") : 0.0), + rtol=host.real("rtol"), atol=host.real("atol"), + cache_propagators=host.has("cache_propagators") ? host.flag("cache_propagators") : true, + # A binary32 state is held as a / s, s an exact power of two (SEP 33, rule 2). + scale=host.has("state_scale") ? host.real("state_scale") : 1.0, + ) + engine = c.free ? create_free(c, host) : create_modal(c, host) + oncpu(c) || (SYNCHRONIZE[] = () -> KA.synchronize(backend)) + compile!(engine) + warm!(engine) + engine +end + +const ACCELERATE = "/System/Library/Frameworks/Accelerate.framework/Accelerate" +"""Forward libblastrampoline's BLAS and LAPACK to Accelerate's new interfaces (macOS 13.4 +and later), LP64 and ILP64, keeping OpenBLAS beneath for what Accelerate lacks, as +AppleAccelerate.jl does (the `\x1a` marks an exact suffix); then set Accelerate +single-threaded (macOS 15 and later), since the engine's pool already splits its +products into blocks of rows (`gemm!`). Return the configuration.""" +function use_accelerate!() + Sys.isapple() || throw(ArgumentError("SOLPROP_JULIA_BLAS=accelerate needs macOS")) + BLAS.lbt_forward(ACCELERATE; suffix_hint="\x1a\$NEWLAPACK") + BLAS.lbt_forward(ACCELERATE; suffix_hint="\x1a\$NEWLAPACK\$ILP64") + # BLASSetThreading(BLAS_THREADING_SINGLE_THREADED = 1) returns 0 on success. + ccall((:BLASSetThreading, ACCELERATE), Cint, (Cint,), 1) == 0 || + throw(ErrorException("Accelerate's BLASSetThreading failed")) + BLAS.get_config() +end + +"""Set or clear flush-to-zero (and denormals-are-zero) for the engine's numerical work. + +A CPU's floating-point control register is per thread. Julia's other threads run only +pool tasks, so theirs is set for good; thread one is the Python interpreter's own, +whose NumPy and `math` must keep subnormals (a flushed one made a `math.log` of a +tiny positive value fail), so the entry points set it on entry and restore it on exit +(`flushed`). GPU kernels are unaffected.""" +function flush_subnormals!(on::Bool) + FTZ[] = on + Threads.@threads :static for k in 1:Threads.nthreads() + k == 1 || set_zero_subnormals(on) + end + nothing +end +const FTZ = Ref(false) +@inline function flushed(f::F, args...) where {F} + FTZ[] || return f(args...) + previous = get_zero_subnormals() + set_zero_subnormals(true) + try + f(args...) + finally + set_zero_subnormals(previous) + end +end + +"""Run each path once on the zero state, then forget it: a GPU's kernels compile at +their first launch, which `compile!`'s inference does not reach.""" +function warm!(engine) + c, w = engine.config, engine.work + a = w.adams + if c.low_storage + rk4!(engine, 1e-12, 1e-12) + elseif a !== nothing + # Valid history rows, so that no warm trial reads outside the store. + fill!(a.host.slots, 1) + copyto!(a.device.slots, a.host.slots) + adams_start!(engine) + for n in 1:size(a.moments, 3) + a.sizes .= (min(n, size(a.moments, 3) - 1), n, 1) + adams_trial_width!(engine, 1e-12, Val(n)) + end + adams_accept!(engine, 1) + fill!(a.sizes, 0) + else + trial!(engine, 1e-12) + end + commit!(engine, 1e-12, true) + # The observers' paths too: the monitor, the edge (on a provisional binding), the + # occupancy and the populations. + state_power(engine) + host_state(engine) + occupancy(engine) + nm = size(w.y, 2) + bind_edge!(engine, c.free ? nothing : Matrix{Float64}(I, nm, nm), [0]) + node_energy(engine) + column_energy(engine) + w.edge[] = nothing + w.plasma === nothing || population_snapshot(engine, nothing) + reset_work!(engine) +end + +"""Zero the state and every buffer a warm-up wrote, and the engine's counters.""" +function reset_work!(engine) + c, w = engine.config, engine.work + a = w.adams + buffers = (w.y, w.candidate, w.lab, w.source, w.error, w.stages, w.forward, w.inverse) + a === nothing || (buffers = (buffers..., a.store, a.states, a.rates, a.moments, a.carried, a.endpoint)) + foreach(buffer -> fill!(buffer, 0), buffers) + engine.fsal_valid, engine.calls, engine.propagator_dz = false, 0, NaN + engine.alarm, engine.alarm_ready = NaN, false + engine.version += 1 + TIMING[] && empty!(TIMES) + COUNT[] && empty!(COUNTS) + nothing +end + +"""Compile every entry point the march calls for this engine's types, now. + +Construction is timed apart from propagation; without this, a run's first step and +first boundary reading pay seconds of compilation inside the propagation's time. +""" +function compile!(engine) + E = typeof(engine) + for (f, arguments) in ((trial!, (E, Float64)), (commit!, (E, Float64, Bool)), + (rk4!, (E, Float64, Float64)), (state_power, (E,)), + (split_power, (E,)), (occupancy, (E,)), (host_state, (E,)), + (host_candidate, (E,)), (adams_start!, (E,)), (adams_accept!, (E, Int)), + (material_stage!, (E, Int)), (reset!, (E,))) + precompile(f, arguments) + end + a = engine.work.adams + if a !== nothing + for n in 1:size(a.moments, 3) + precompile(adams_trial_width!, (E, Float64, Val{n})) + end + end + nothing +end + +function reset!(engine) + engine.version += 1 + mask!(engine, engine.work.y) + engine.fsal_valid = false + engine.calls = 0 + nothing +end +device_matrix(engine, input) = + upload(engine.config.backend, Matrix{Complex{real_type(engine)}}(input)) + +function mask!(engine, values) + mask = engine.config.mask + each!(engine.config, size(values)...) do f, m + @inbounds if !mask[f] + values[f, m] = 0 + end + end +end + +complex_host(a) = Matrix{ComplexF64}(Array(a)) +function evaluate!(engine, input) + copyto!(engine.work.lab, device_matrix(engine, input)) + source!(engine, engine.work.lab) + complex_host(engine.work.source) +end + +# Plans hold implementation-owned storage; the arrays the engine owns are counted. +function ledger(engine) + result = Dict{String,Int}() + function visit(prefix, object) + for name in propertynames(object) + value = getproperty(object, name) + key = "$(prefix).$(name)" + if value isa DenseArray && !isempty(value) + result[key] = sizeof(value) + elseif value isa NamedTuple + visit(key, value) + end + end + end + visit("config", engine.config) + visit("work", engine.work) + result +end + +device_name(engine) = device_label(engine.config.backend) +runtime() = (string(VERSION), Threads.nthreads(), FFTW.get_num_threads(), + BLAS.get_num_threads(), string(BLAS.get_config())) +rk4_b(args...) = flushed(rk4!, args...) +const configure_stages_b = configure_stages! +const load_b = load! +const bind_monitor_b = bind_monitor! +const copy_state_b = copy_state! +const bind_edge_b = bind_edge! +trial_b(args...) = flushed(trial!, args...) +commit_b(args...) = flushed(commit!, args...) +evaluate_b(args...) = flushed(evaluate!, args...) +const reset_work_b = reset_work! + + +# The specialisations the benchmark windows compiled (every focus case, binary64, one +# and sixteen threads), replayed when the package is built so that their native code is +# in its image: `julia/src/precompile_trace.jl`, recorded with juliacall's +# `PYTHON_JULIACALL_TRACE_COMPILE`. A statement that no longer resolves is skipped. +import KernelAbstractions, AcceleratedKernels, FFTW, Polyester, Atomix +let file = joinpath(@__DIR__, "precompile_trace.jl") + if ccall(:jl_generating_output, Cint, ()) == 1 && isfile(file) + for line in eachline(file) + try + Base.eval(@__MODULE__, Meta.parse(line)) + catch + end + end + end +end +end diff --git a/julia/src/adams.jl b/julia/src/adams.jl new file mode 100644 index 000000000..4f93d4573 --- /dev/null +++ b/julia/src/adams.jl @@ -0,0 +1,399 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# SEP 16's resident exponential predictor-corrector. The Python march chooses steps +# and orders and supplies the scalar coefficient tables; the history and every +# state-sized operation stay here. + +const RECIP_FACTORIAL = ntuple(k -> 1.0 / factorial(k - 1), 10) + +const RECIP_INTEGER = ntuple(k -> 1.0 / k, 40) + +# The tables in the wide type: binary64's are the engine's original constants, the +# double-float ones the same binary64 values split. +recip_factorial(::Type{Float64}, k) = @inbounds RECIP_FACTORIAL[k] +recip_integer(::Type{Float64}, k) = @inbounds RECIP_INTEGER[k] +const RECIP_FACTORIAL_DF = map(DF32, RECIP_FACTORIAL) +const RECIP_INTEGER_DF = map(DF32, RECIP_INTEGER) +recip_factorial(::Type{DF32}, k) = @inbounds RECIP_FACTORIAL_DF[k] +recip_integer(::Type{DF32}, k) = @inbounds RECIP_INTEGER_DF[k] + +# The size that picks the branch and the halvings: binary64's `abs`, or the high +# parts' modulus in binary32 (the choice needs no more). +phi_size(x::ComplexF64) = abs(x) +phi_size(x::CDF32) = sqrt(real(x).hi * real(x).hi + imag(x).hi * imag(x).hi) +# The series' stop: binary64's squared test as it was; on pairs a one-norm test on the +# high parts, whose squares would be subnormal in binary32 for a small sum. +series_done(term::ComplexF64, total::ComplexF64, stop) = abs2(term) <= stop^2 * abs2(total) +series_done(term::CDF32, total::CDF32, stop) = + abs(real(term).hi) + abs(imag(term).hi) <= stop * (abs(real(total).hi) + abs(imag(total).hi)) +# `value 2^-k`, exactly: binary64's expression as it was, halvings on pairs. +scale_down(value::ComplexF64, k) = value * 0.5^k +scale_down(value::CDF32, k) = halve(value, k) +# k! phi_{k+1}: binary64 divides by the reciprocal, as it did; on pairs the factorial +# (exact in binary32 to 10!) multiplies. +moment_of(value::ComplexF64, k) = value / RECIP_FACTORIAL[k] +moment_of(value::CDF32, k) = value * Float32(factorial(k - 1)) + +"""`phi_0(x) .. phi_N(x)` by a shifted series and scaling and squaring. + +Evaluated in the wide type at either precision (binary64, or a double-float where the +device lacks it): the flow and its moments are rounded once to the state's precision +(SEP 33). Native's `adams_phi` (adams_phi.hpp) is the model: past |x| = 3 the +recurrence from `exp(x)` with one reciprocal of x; below it the series of `phi_N(y)`, +`y = x / 2^s` with |y| <= 1/2, multiplied by the divisors' reciprocals and stopped +once a term is under a quarter ulp of the sum (each later one is smaller by +|y| / (m + N) <= 1/2), then raised back by `s` squarings. In binary64 the operations +are exactly the original ones. +""" +@inline function phi_values(x::Complex{W}, ::Val{N}) where {W,N} + magnitude = phi_size(x) + S = typeof(magnitude) + out = ntuple(_ -> zero(Complex{W}), Val(N + 1)) + if magnitude > S(3) + inverse = inv(x) + out = Base.setindex(out, exp(x), 1) + for k in 1:N + out = Base.setindex(out, (out[k] - recip_factorial(W, k)) * inverse, k + 1) + end + return out + end + half = S(0.5) + levels, scale = 0, one(S) + reduced = magnitude + while reduced > half + levels += 1 + scale *= half + reduced *= half + end + y = scale * x + term = complex(recip_factorial(W, N + 1)) + total = term + stop = S(0.25) * S(eps(W)) + for m in 1:23 + term = term * y * recip_integer(W, m + N) + total += term + series_done(term, total, stop) && break + end + out = Base.setindex(out, total, N + 1) + for k in N-1:-1:1 + out = Base.setindex(out, muladd(y, out[k+2], recip_factorial(W, k + 1)), k + 1) + end + out = Base.setindex(out, exp(y), 1) + for _ in 1:levels + old = out + out = Base.setindex(out, old[1] * old[1], 1) + for k in 1:N + value = old[1] * old[k+1] + for j in 1:k + value = muladd(old[j+1], recip_factorial(W, k - j + 1), value) + end + out = Base.setindex(out, scale_down(value, k), k + 1) + end + end + out +end +phi_snapshot(x, order) = collect(phi_values(ComplexF64(x), Val(Int(order)))) +# The double-float evaluation of the same, widened back for comparison (tests). +phi_snapshot_df(x, order) = + [ComplexF64(Float64(real(v)), Float64(imag(v))) + for v in phi_values(only(widen_host(DF32, [ComplexF64(x)])), Val(Int(order)))] + +function adams_workspace(c, host, nw, nm) + order = host.has("adams_order") ? host.int("adams_order") : 0 + order == 0 && return nothing + C = Complex{c.T} + slots, width = order + 2, order + 1 + compensated = host.flag("adams_compensated") + held(dims...) = compensated ? dzeros(c, C, dims...) : dzeros(c, C, ntuple(_ -> 0, length(dims))...) + nphi = host.has("phi_terms") ? size(host.array("phi_terms", ComplexF64), 3) : 1 + # The trial's coefficient tables, filled on the host and copied over once a trial. + tables = (predictor=zeros(width, width), corrector=zeros(width, width), + defects=zeros(3, 2width), spans=zeros(width), cpredictor=zeros(width), + ccorrector=zeros(width + 1), cdefects=zeros(3, width), rate=zeros(nphi), + slots=zeros(Int, slots)) + tables_on_device = device_tables(c, tables) + (store=dzeros(c, C, nw, nm, slots), states=held(nw, nm, slots), rates=held(nw, nm, slots), + moments=dzeros(c, C, nw, nm, width), carried=held(nw, nm, max(width - 1, 0)), + # The device's tables at the state's precision: a binary64 coefficient beside a + # binary32 state would widen a trial's every product (and its norms' types). + endpoint=held(nw, nm), host=tables, + device=tables_on_device.device, packed=tables_on_device.packed, + sizes=zeros(Int, 3), compensated=compensated) +end + +"""The device's copies of the trial's tables: on a CPU an array each; on a GPU the real +tables views of one device vector (`packed`), refreshed by one copy a trial with the +integer slots beside it (`upload_tables!`), where nine small uploads a trial were nine +round trips through the copy engine.""" +function device_tables(c, tables) + if oncpu(c) + device = map(a -> upload(c.backend, eltype(a) <: Integer ? copy(a) : c.T.(a)), tables) + return (device=device, packed=nothing) + end + reals = Base.structdiff(tables, NamedTuple{(:slots,)}) + total = sum(length, values(reals)) + packed = dzeros(c, c.T, total) + stops = cumsum(collect(map(length, values(reals)))) + views = ntuple(k -> reshape(view(packed, stops[k]-length(reals[k])+1:stops[k]), size(reals[k])), + length(reals)) + device = merge(NamedTuple{keys(reals)}(views), (slots=upload(c.backend, copy(tables.slots)),)) + (device=device, packed=(device=packed, host=zeros(c.T, total))) +end + +"""Copy the host's trial tables to the device: each on a CPU, one packed copy and the +slots on a GPU.""" +function upload_tables!(a) + packed = hasproperty(a, :packed) ? a.packed : nothing + if packed === nothing + foreach(copyto!, a.device, a.host) + return nothing + end + staging, offset = packed.host, 0 + for name in keys(a.host) + name === :slots && continue + table = getproperty(a.host, name) + for k in eachindex(table) + @inbounds staging[offset+k] = table[k] + end + offset += length(table) + end + tally!(:upload, 2) + copyto!(packed.device, staging) + copyto!(a.device.slots, a.host.slots) + nothing +end + +function configure_adams!(engine, predictor, corrector, defects, slots, spans, cpredictor, + ccorrector, cdefects, rate) + a = engine.work.adams + h = a.host + p, q, d = Matrix{Float64}(predictor), Matrix{Float64}(corrector), Matrix{Float64}(defects) + order, width, count = size(p, 1), size(q, 1), size(d, 1) + a.sizes .= (order, width, count) + h.predictor[1:order, 1:order] .= p + h.corrector[1:width, 1:width] .= q + h.defects[1:count, 1:2width] .= d + incoming = Vector{Int}(slots) + h.slots[1:length(incoming)] .= incoming .+ 1 + if a.compensated + s, cp, cc = Vector{Float64}(spans), Vector{Float64}(cpredictor), Vector{Float64}(ccorrector) + h.spans[1:length(s)] .= s + h.cpredictor[1:length(cp)] .= cp + h.ccorrector[1:length(cc)] .= cc + h.cdefects[1:count, 1:width] .= Matrix{Float64}(cdefects) + h.rate .= Vector{Float64}(rate) + end + upload_tables!(a) + nothing +end +function configure_adams_rate!(engine, rate) + a = engine.work.adams + a.host.rate .= Vector{Float64}(rate) + upload_tables!(a) + nothing +end + +"""`D(z)` at one element: the constant operator, or its expansion's weighted terms.""" +@inline function adams_rate(linear, phi, weights, f, m) + phi === nothing && return @inbounds linear[f, m] + value = zero(eltype(phi)) + @inbounds for term in axes(phi, 3) + value += phi[f, m, term] * weights[term] + end + value +end + +path_terms(w) = w.path === nothing ? nothing : w.path.phi + +function adams_start!(engine) + c, w = engine.config, engine.work + a = w.adams + w.path === nothing || material_stage!(engine, 1) + source!(engine, w.y) + pool_copy!(@view(a.store[:, :, 1]), w.source, c) + if a.compensated + pool_copy!(@view(a.states[:, :, 1]), w.y, c) + (; rates) = a + linear, phi, weights = c.linear, path_terms(w), a.device.rate + each!(c, size(w.y)...) do f, m + @inbounds rates[f, m, 1] = adams_rate(linear, phi, weights, f, m) + end + end + nothing +end + +adams_trial!(engine, h) = adams_trial_width!(engine, h, Val(engine.work.adams.sizes[2])) + +function adams_trial_width!(engine, h, ::Val{N}) where {N} + c, w = engine.config, engine.work + a = w.adams + order, _, count = a.sizes + T = real_type(engine) + C = Complex{T} + (; y, lab, error, forward, candidate, source) = w + (; store, states, rates, moments, carried, endpoint) = a + (; predictor, corrector, defects, spans, cpredictor, ccorrector, cdefects, slots) = a.device + linear, phi, weights, compensated = c.linear, path_terms(w), a.device.rate, a.compensated + delta = w.path === nothing ? nothing : w.path.delta_device + # The step in the wide type, split on the host; a kernel body captures values only. + step = wide_value(c, Float64(h)) + xzero = complex(zero(c.wide)) + mask = c.norm_mask + # The predictor, the flow and its moments, and the state's norm for the scale. + active = c.mask + none, nil, h = zero(T), zero(C), T(step) + # The state's squared norm, for the corrector's scale, stays where the corrector + # reads it: on a GPU the device (`sum_device!`). + squared = scratch(c, :adams_squared, T, 1) + @section :adams_predict sum_device!(squared, c, size(y)...; heavy=true) do f, m + @inbounds begin + # Outside the band the state, the history and the source are exactly zero, + # and so is everything this element forms. + if !active[f] + lab[f, m] = 0 + compensated && (endpoint[f, m] = 0; error[f, m] = 0) + return none + end + x = step * linear[f, m] + if phi !== nothing + x = xzero + for term in axes(phi, 3) + x += phi[f, m, term] * delta[term, 7] + end + end + values = phi_values(x, Val(N)) + forward[f, m, 1] = values[1] + predicted = nil + for k in 1:N + moment = oftype(nil, moment_of(values[k+1], k)) + moments[f, m, k] = moment + if k <= order + weighted = nil + for j in 1:order + weighted = muladd(predictor[j, k], store[f, m, slots[j]], weighted) + end + predicted = muladd(moment, weighted, predicted) + end + end + if compensated + correction = nil + for j in 1:N-1 + slot = slots[j] + value = oftype(nil, exp(spans[j] * x)) * (rates[f, m, slot] - oftype(nil, x / step)) * states[f, m, slot] + carried[f, m, j] = value + j <= order && (correction = muladd(cpredictor[j], value, correction)) + end + predicted += correction + error[f, m] = adams_rate(linear, phi, weights, f, m) + end + value = muladd(h, predicted, oftype(nil, values[1]) * y[f, m]) + lab[f, m] = value + compensated && (endpoint[f, m] = (error[f, m] - oftype(nil, x / step)) * value) + mask[f] ? abs2(y[f, m]) : none + end + end + w.path === nothing || material_stage!(engine, 7) + source!(engine, lab; quadrature=true) + # A GPU reads the quadrature alarm with the norms, for the commit to take. + alarm = oncpu(c) ? nothing : alarm_arrays(engine) + norms = @section :adams_correct corrector_norms(engine, Val(N), squared, h, alarm) + alarm === nothing || hold_alarm!(engine, norms) + [sqrt(Float64(norms[row])) for row in 1:count] +end + +"""The corrected candidate and the defect norms' squares, one to three, and with an +`alarm` (`alarm_arrays`) its two sums after them, in one reduction: one value the host +waits for a trial.""" +function corrector_norms(engine, ::Val{N}, squared, h, alarm) where {N} + c, w = engine.config, engine.work + a = w.adams + order, _, count = a.sizes + T = real_type(engine) + C = Complex{T} + (; y, forward, candidate, source) = w + (; store, moments, carried, endpoint) = a + (; corrector, defects, ccorrector, cdefects, slots) = a.device + compensated = a.compensated + active, mask, weight = c.mask, c.norm_mask, c.weights + rtol, absolute = T(c.rtol), T(c.atol) + none, nil = zero(T), zero(C) + zero3 = (none, none, none) + neutral = alarm === nothing ? zero3 : (zero3..., none, none) + reduce_each(.+, neutral, c, size(y)...; heavy=true) do f, m + @inbounds begin + extra = alarm === nothing ? () : alarm_term(alarm, f, m) + if !active[f] + candidate[f, m] = 0 + return (zero3..., extra...) + end + corrected = nil + for k in 1:N + weighted = corrector[1, k] * source[f, m] + for j in 2:N + weighted = muladd(corrector[j, k], store[f, m, slots[j-1]], weighted) + end + corrected = muladd(moments[f, m, k], weighted, corrected) + end + if compensated + correction = ccorrector[1] * endpoint[f, m] + for j in 1:order + correction = muladd(ccorrector[j+1], carried[f, m, j], correction) + end + corrected += correction + end + candidate[f, m] = muladd(h, corrected, forward[f, m, 1] * y[f, m]) + result = zero3 + if mask[f] + # rtol |y|, formed as the host formed it from the predictor's sum. + relative = rtol * sqrt(squared[1]) + scale = relative * weight[f] + absolute + for row in 1:count + difference = defects[row, 1] * source[f, m] + for j in 2:N + difference += defects[row, j] * store[f, m, slots[j-1]] + end + polynomial = nil + for k in 1:N + polynomial += defects[row, N+k] * moments[f, m, k] + end + defect = difference * polynomial + if compensated + correction = cdefects[row, 1] * endpoint[f, m] + for j in 1:N-1 + correction += cdefects[row, j+1] * carried[f, m, j] + end + defect += correction + end + defect *= h + score = scale == 0 && defect == 0 ? none : abs2(defect / scale) + result = Base.setindex(result, score, row) + end + end + (result..., extra...) + end + end +end + +function adams_accept!(engine, slot) + w = engine.work + a = w.adams + pool_copy!(@view(a.store[:, :, slot+1]), w.source, engine.config) + if a.compensated + pool_copy!(@view(a.states[:, :, slot+1]), w.lab, engine.config) + pool_copy!(@view(a.rates[:, :, slot+1]), w.error, engine.config) + end + nothing +end +adams_rows(engine, name) = Array{ComplexF64}(Array(getproperty(engine.work.adams, Symbol(name)))) +function adams_load_rows!(engine, name, rows) + target = getproperty(engine.work.adams, Symbol(name)) + copyto!(target, upload(engine.config.backend, Array{eltype(target),3}(rows))) + nothing +end +const configure_adams_b = configure_adams! +const configure_adams_rate_b = configure_adams_rate! +adams_start_b(args...) = flushed(adams_start!, args...) +adams_trial_b(args...) = flushed(adams_trial!, args...) +adams_accept_b(args...) = flushed(adams_accept!, args...) +const adams_load_rows_b = adams_load_rows! diff --git a/julia/src/dfloat.jl b/julia/src/dfloat.jl new file mode 100644 index 000000000..ea0115a5c --- /dev/null +++ b/julia/src/dfloat.jl @@ -0,0 +1,205 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Double-float: a value carried as the unevaluated sum of two binary32s, about 48 +# significand bits. A binary32 run on a device without fast binary64 (an Apple GPU +# has none, an A40 runs it at 1/64 rate) forms the operator's exponents, the +# propagators and the Adams flow in it, and rounds each result once to binary32: the +# precision SEP 33 asks of them (4.1 item 3). The state itself stays binary32. +# +# The primitives are the mlx backend's (src/solprop/backends/mlx_gpu/arithmetic.py), +# whose accuracy SEP 33 measured: Knuth's two-sum, the fused two-product, and complex +# arithmetic on pairs. Every operation here is plain Julia over Float32, so the same +# code runs in a CPU loop, a CUDA kernel or a Metal kernel. Nothing here may be +# reassociated or contracted; Julia does neither without `@fastmath` or `muladd`. + +"""A double-float: `hi + lo` with `|lo| <= ulp(hi) / 2`.""" +struct DF32 <: AbstractFloat + hi::Float32 + lo::Float32 +end + +@inline function two_sum(a::Float32, b::Float32) + s = a + b + bb = s - a + s, (a - (s - bb)) + (b - bb) +end +@inline function quick_two_sum(a::Float32, b::Float32) + s = a + b + s, b - (s - a) +end +@inline function two_prod(a::Float32, b::Float32) + p = a * b + p, fma(a, b, -p) +end + +DF32(x::Float32) = DF32(x, 0.0f0) +DF32(x::DF32) = x +# On the host only: a binary64 value split exactly enough (the pair holds 48 bits). +function DF32(x::Float64) + hi = Float32(x) + DF32(hi, Float32(x - Float64(hi))) +end +# Integers exactly, without binary64: the remainder of the rounded high part. +function DF32(x::Integer) + hi = Float32(x) + DF32(hi, Float32(x - unsafe_trunc(typeof(x), hi))) +end +Base.Float32(x::DF32) = x.hi + x.lo +Base.Float64(x::DF32) = Float64(x.hi) + Float64(x.lo) +Base.promote_rule(::Type{DF32}, ::Type{Float32}) = DF32 +Base.promote_rule(::Type{DF32}, ::Type{<:Integer}) = DF32 + +Base.zero(::Type{DF32}) = DF32(0.0f0, 0.0f0) +Base.one(::Type{DF32}) = DF32(1.0f0, 0.0f0) +Base.zero(::DF32) = zero(DF32) +Base.one(::DF32) = one(DF32) +# The pair's unit roundoff, about 2^-48 (Float32's 24 bits twice). +Base.eps(::Type{DF32}) = DF32(Float32(2.0^-48), 0.0f0) +Base.isnan(x::DF32) = isnan(x.hi) +Base.isinf(x::DF32) = isinf(x.hi) +Base.isfinite(x::DF32) = isfinite(x.hi) +Base.iszero(x::DF32) = iszero(x.hi) +Base.signbit(x::DF32) = signbit(x.hi) + +@inline function Base.:+(x::DF32, y::DF32) + s, e = two_sum(x.hi, y.hi) + DF32(quick_two_sum(s, (e + x.lo) + y.lo)...) +end +@inline Base.:-(x::DF32) = DF32(-x.hi, -x.lo) +@inline Base.:-(x::DF32, y::DF32) = x + (-y) +@inline function Base.:*(x::DF32, y::DF32) + p, e = two_prod(x.hi, y.hi) + DF32(quick_two_sum(p, fma(x.hi, y.lo, fma(x.lo, y.hi, e)))...) +end +# A binary32 factor exactly: the product of the high part and the low part's term. +@inline function Base.:*(x::DF32, y::Float32) + p, e = two_prod(x.hi, y) + DF32(quick_two_sum(p, fma(x.lo, y, e))...) +end +@inline Base.:*(y::Float32, x::DF32) = x * y +@inline function Base.:/(a::DF32, b::Float32) + q1 = a.hi / b + p, e = two_prod(q1, b) + r = ((a.hi - p) - e) + a.lo + DF32(quick_two_sum(q1, r / b)...) +end +@inline function Base.:/(a::DF32, b::DF32) + q1 = a.hi / b.hi + r = a - b * q1 + q2 = r.hi / b.hi + r = r - b * q2 + q3 = r.hi / b.hi + DF32(quick_two_sum(q1, q2)...) + DF32(q3) +end +@inline Base.inv(x::DF32) = one(DF32) / x +@inline Base.abs(x::DF32) = signbit(x.hi) ? -x : x +@inline Base.:<(x::DF32, y::DF32) = x.hi < y.hi || (x.hi == y.hi && x.lo < y.lo) +@inline Base.:<=(x::DF32, y::DF32) = x.hi < y.hi || (x.hi == y.hi && x.lo <= y.lo) +@inline Base.:(==)(x::DF32, y::DF32) = x.hi == y.hi && x.lo == y.lo + +# Complex double-floats: Base's generic `+`, `-`, `*` and `abs2` serve; the division, +# the reciprocal and the exponential are written out, since Base's forms scale through +# `abs`, `floatmin` and binary64 constants. +const CDF32 = Complex{DF32} +@inline function Base.:/(a::CDF32, b::CDF32) + d = real(b) * real(b) + imag(b) * imag(b) + Complex((real(a) * real(b) + imag(a) * imag(b)) / d, + (imag(a) * real(b) - real(a) * imag(b)) / d) +end +@inline Base.inv(b::CDF32) = Complex(one(DF32), zero(DF32)) / b +@inline Base.:/(a::CDF32, b::DF32) = Complex(real(a) / b, imag(a) / b) + +const TWO_PI_DF = DF32(2pi) +const INV_TWO_PI_32 = Float32(1 / 2pi) + +"""A phase less whole turns of a double-float 2 pi, as a double-float: about 2^-48 of +the phase for one of up to 1e7 rad.""" +@inline function reduce_phase(phase::DF32) + turns = round(phase.hi * INV_TWO_PI_32) + phase + TWO_PI_DF * (-turns) +end + +"""`exp(y)` for `|y| <= 1/2`: Horner's form of 18 Taylor terms (a tail below 2^-60).""" +@inline function exp_small(y::CDF32) + e = Complex(one(DF32), zero(DF32)) + for m in 18:-1:1 + p = e * y + e = Complex(real(p) / Float32(m) + one(DF32), imag(p) / Float32(m)) + end + e +end + +"""Scale by `2^-s`, exactly: `s` halvings of both parts.""" +@inline function halve(x::CDF32, s) + for _ in 1:s + x = Complex(real(x) * 0.5f0, imag(x) * 0.5f0) + end + x +end + +"""`exp(x)` in double-float: the phase reduced by whole turns of 2 pi, the argument +halved to at most 1/2, the series, and squared back.""" +@inline function Base.exp(x::CDF32) + r = Complex(real(x), reduce_phase(imag(x))) + size = sqrt(real(r).hi * real(r).hi + imag(r).hi * imag(r).hi) + s = 0 + while size > 0.5f0 + size *= 0.5f0 + s += 1 + end + e = exp_small(halve(r, s)) + for _ in 1:s + e = e * e + end + e +end + +"""`exp(+-z)` rounded once to binary32 each, for a propagator pair. + +With `W = Float64` it is Base's binary64 exponential, as the engine always formed it. +In double-float it is the mlx backend's pair (arithmetic.py, `_PAIR`): the phase +reduced by turns of 2 pi, binary32 cosine and sine of the reduced angle, renormalised +by one Newton step on the double-float squared modulus (binary32 cosine and sine +leave it a few u off one, with a bias a long march accumulates in the energy), and +the magnitude `exp(hi) (1 + lo)`. +""" +@inline wide_exp_pair(z::ComplexF64) = (exp(z), exp(-z)) +@inline function wide_exp_pair(z::CDF32) + re = real(z) + phase = reduce_phase(imag(z)) + angle = phase.hi + phase.lo + c, s = cos(angle), sin(angle) + norm = DF32(two_prod(c, c)...) + DF32(two_prod(s, s)...) + delta = -0.5f0 * ((norm.hi - 1.0f0) + norm.lo) + cc, ss = fma(c, delta, c), fma(s, delta, s) + forward = exp(re.hi) * (1.0f0 + re.lo) + back = exp(-re.hi) * (1.0f0 - re.lo) + (Complex(forward * cc, forward * ss), Complex(back * cc, -(back * ss))) +end +@inline wide_exp(z::ComplexF64) = exp(z) +@inline wide_exp(z::CDF32) = first(wide_exp_pair(z)) + +"""The wide type of a binary32 run: `"binary64"` (the default off Metal) or `"df32"`.""" +function wide_type(T, choice) + T === Float64 && return Float64 + choice == "binary64" && return Float64 + choice == "df32" && return DF32 + throw(ArgumentError("SOLPROP_JULIA_WIDE must be binary64 or df32")) +end + +# The engine's wide type is held as a zero of it (`c.wide`): a type in a named tuple is +# a `DataType` to inference, a value is concrete. +wide_eltype(c) = typeof(c.wide) +"""A host binary64 scalar in the engine's wide type: itself, or split into a pair.""" +wide_value(c, x::Float64) = oftype(c.wide, x) + +"""A host binary64 array in the engine's wide type, for `upload`.""" +widen_host(::Type{Float64}, a::AbstractArray{<:Union{Float64,ComplexF64}}) = a +widen_host(::Type{DF32}, a::AbstractArray{Float64}) = DF32.(a) +widen_host(::Type{DF32}, a::AbstractArray{ComplexF64}) = + [Complex(DF32(real(z)), DF32(imag(z))) for z in a] + +# The double-float propagator pair of a binary64 exponent, widened back (tests). +exp_pair_snapshot_df(z) = + map(ComplexF64, wide_exp_pair(only(widen_host(DF32, [ComplexF64(z)])))) diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl new file mode 100644 index 000000000..a9c297fa5 --- /dev/null +++ b/julia/src/dopri.jl @@ -0,0 +1,232 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# The interaction-picture DOPRI5 trial and the accepted step's commit. + +"""Cache `exp(+-c_s dz L)` per stage: exact reuse while dz is unchanged.""" +function propagators!(engine, dz) + c, w = engine.config, engine.work + c.free && return nothing + if w.path !== nothing + path_propagators!(engine) + return nothing + end + c.cache_propagators && engine.propagator_dz == dz && return nothing + (; linear) = c + (; forward, inverse) = w + # Formed on the host in binary64, then split where the wide type is a pair. + steps = ntuple(s -> wide_value(c, dz * c.nodes_c[s]), Val(7)) + each!(c, size(linear)...) do f, m + @inbounds for s in 1:7 + forward[f, m, s], inverse[f, m, s] = wide_exp_pair(steps[s] * linear[f, m]) + end + end + engine.propagator_dz = dz + nothing +end + +"""Form one IP-DOPRI5 candidate and its error; the accepted state is untouched. + +Returns the scaled error norm. With a valid first-same-as-last sample the first stage +is the previous step's last source, which `commit!` left in stage one's slot. +""" +function trial!(engine, dz::Float64) + c, w = engine.config, engine.work + T = real_type(engine) + (; y, lab, stages, forward, inverse, source) = w + @section :propagators propagators!(engine, dz) + for stage in 1:7 + stage == 1 && engine.fsal_valid && continue + w.path !== nothing && material_stage!(engine, stage) + if stage == 1 + # c_1 = 0: both propagators are exactly the identity. + if !engine.fsal_valid + source!(engine, y) + pool_copy!(@view(stages[:, :, 1]), source, c) + end + continue + end + slot = c.free ? (@section :propagators free_propagators!(engine, dz * c.nodes_c[stage])) : stage + row = ntuple(p -> T(dz * c.a[stage, p]), Val(6)) + @section :stage_input each!(c, size(y)...) do f, m + @inbounds begin + combination = zero(eltype(y)) + for p in 1:stage-1 + combination = muladd(row[p], stages[f, m, p], combination) + end + lab[f, m] = forward[f, m, slot] * (y[f, m] + combination) + end + end + @section :source source!(engine, lab; quadrature=stage == 7) + @section :stage_output each!(c, size(y)...) do f, m + @inbounds stages[f, m, stage] = inverse[f, m, slot] * source[f, m] + end + end + engine.fsal_valid = true + @section :combine combine!(engine, dz, c.free ? 1 : 7) +end + +"""The candidate and the error estimate, and the controller's norm of the error. + +The norm is `‖e‖ / (rtol w max(‖y‖, ‖y_new‖) + atol)` over the in-band bins, as the +shared controller defines it; with uniform weights all three sums are one pass. +""" +function combine!(engine, dz, slot) + c, w = engine.config, engine.work + T = real_type(engine) + (; y, candidate, error, stages, forward) = w + mask = c.norm_mask + b = ntuple(s -> T(dz * c.b[s]), Val(7)) + e = ntuple(s -> T(dz * c.e[s]), Val(7)) + # A GPU reads the quadrature alarm with the norms, for the commit to take. + alarm = oncpu(c) ? nothing : alarm_arrays(engine) + sums = combine_sums(y, candidate, error, stages, forward, mask, b, e, slot, alarm, c, T) + alarm === nothing || hold_alarm!(engine, sums) + magnitude = max(sqrt(sums[1]), sqrt(sums[2])) + if c.uniform + scale = T(c.rtol) * magnitude + T(c.atol) + return scale == 0 ? (sums[3] == 0 ? 0.0 : Inf) : Float64(sqrt(sums[3]) / scale) + end + weighted_norm(engine, error, magnitude) +end + +function combine_sums(y, candidate, error, stages, forward, mask, b, e, slot, alarm, c, T) + zero3 = (zero(T), zero(T), zero(T)) + neutral = alarm === nothing ? zero3 : (zero3..., zero(T), zero(T)) + reduce_each(.+, neutral, c, size(y)...) do f, m + @inbounds begin + extra = alarm === nothing ? () : alarm_term(alarm, f, m) + solution, defect = zero(eltype(y)), zero(eltype(y)) + for s in 1:7 + value = stages[f, m, s] + solution = muladd(b[s], value, solution) + defect = muladd(e[s], value, defect) + end + flow = forward[f, m, slot] + new = flow * (y[f, m] + solution) + estimate = flow * defect + candidate[f, m] = new + error[f, m] = estimate + ((mask[f] ? (abs2(y[f, m]), abs2(new), abs2(estimate)) : zero3)..., extra...) + end + end +end + +function weighted_norm(engine, error, magnitude) + c = engine.config + T = real_type(engine) + (; weights, norm_mask) = c + relative, absolute = T(c.rtol) * magnitude, T(c.atol) + nothing_ = zero(T) + residual = reduce_each(+, nothing_, c, size(error)...) do f, m + @inbounds begin + scale = relative * weights[f] + absolute + value = error[f, m] + norm_mask[f] && !(scale == 0 && value == 0) ? abs2(value / scale) : nothing_ + end + end + Float64(sqrt(residual)) +end + +"""Accept the candidate: the mask, the split-step collar, then the quadrature alarm.""" +commit!(engine, dz::Float64, monitored::Bool=false) = @section :commit commit_step!(engine, dz, monitored) +function commit_step!(engine, dz, monitored) + c, w = engine.config, engine.work + mask!(engine, w.candidate) + if c.split_active + # With a split monitor bound, the power the split finds (`split_power`). + c.free ? split_free!(engine, dz, monitored) : split_modal!(engine, dz, monitored) + mask!(engine, w.candidate) + engine.fsal_valid = false + elseif !c.low_storage && w.adams === nothing + # The last stage's source is the next trial's first. + pool_copy!(@view(w.stages[:, :, 1]), w.source, c) + engine.fsal_valid = true + end + pool_copy!(w.y, w.candidate, c) + engine.version += 1 + c.embedded ? quadrature_alarm(engine) : NaN +end + +function split_modal!(engine, dz, monitored) + c, w = engine.config, engine.work + (; coarse) = w + mul!(coarse, w.coarse_inverse, w.candidate) + if monitored + fill!(w.monitor.split, 0) + add_power!(w.monitor.split, coarse, w.monitor.columns, 1, size(coarse, 2), c) + end + rate = c.coarse_rate + T = real_type(engine) + # The unnormalised inverse's 1/nc is folded into the collar's factor. + half, inverse = T(-0.5 * dz), inv(T(c.nc)) + factor = collar_factor(rate, half, inverse, c) + each!(c, size(coarse)...) do t, m + @inbounds coarse[t, m] *= factor[t] + end + mul!(w.candidate, w.coarse_forward, coarse) +end + +"""The collar's half-step factor a sample, `exp(half rate[t]) inverse`, formed once a +sample rather than once an element (384 modes each took the same exponential).""" +function collar_factor(rate, half, inverse, c) + factor = oncpu(c) ? similar(rate) : scratch(c, :collar, eltype(rate), length(rate)) + each!(c, length(rate), 1) do t, _ + @inbounds factor[t] = exp(half * rate[t]) * inverse + end + factor +end + +"""The quadrature alarm's arrays for a reduction body (`alarm_term`), its transforms done: +the exact and the coarse spectra, the crop (`nothing` on the band), the prefactor and +the window; `nothing` without an embedded quadrature.""" +function alarm_arrays(engine) + c, w = engine.config, engine.work + c.embedded || return nothing + c.spectral && return (w.band_source, w.band_coarse, nothing, c.prefactor, c.omega_window) + # A GPU's packed streams: the quadrature source transformed and assembled them. + w.pack === nothing || return (w.fine, w.coarse_spec, c.crop, c.prefactor, c.omega_window) + if w.plasma === nothing + mul!(w.coarse_spec, w.forward_plan, w.projected_coarse) + else + p = w.plasma + transform_all!(w.forward_plan, (w.coarse_spec, p.spectrum, p.edge_spectrum), + (w.projected_coarse, p.coarse, p.coarse_edge), w.forward_stage, c) + add_plasma_spectra!(w.coarse_spec, p, c) + end + (w.fine, w.coarse_spec, c.crop, c.prefactor, c.omega_window) +end + +"""One element's two alarm sums: the exact source's power and its coarse error's.""" +@inline function alarm_term(alarm, f, m) + exact, coarse, crop, prefactor, window = alarm + @inbounds begin + k = crop === nothing ? f : crop[f] + weight = prefactor[f, m] * window[f] + value = weight * exact[k, m] + (abs2(value), abs2(weight * coarse[k, m] - value)) + end +end +alarm_value(power, error) = power == 0 ? NaN : Float64(sqrt(error / power)) + +"""The relative error of the quadrature's coarse source against the exact one: the +GPU trial's own, read with its norms, when it left one (`alarm_ready`).""" +function quadrature_alarm(engine) + if engine.alarm_ready + engine.alarm_ready = false + return engine.alarm + end + alarm = alarm_arrays(engine) + T = real_type(engine) + sums = alarm_sums(alarm, engine.config, T, size(engine.work.y)) + alarm_value(sums...) +end +alarm_sums(alarm, c, T, dims) = + reduce_each((f, m) -> alarm_term(alarm, f, m), .+, (zero(T), zero(T)), c, dims...) +band_alarm(engine) = quadrature_alarm(engine) + +"""Keep a GPU trial's alarm, read with its norms, for the commit.""" +function hold_alarm!(engine, sums) + engine.alarm = alarm_value(sums[end-1], sums[end]) + engine.alarm_ready = true +end diff --git a/julia/src/envelope.jl b/julia/src/envelope.jl new file mode 100644 index 000000000..dc70c3f0d --- /dev/null +++ b/julia/src/envelope.jl @@ -0,0 +1,267 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# The envelope grid's plasma (translate/envelope_plasma.py; the oracle is +# numpy_ref/envelope_plasma.py). Each channel's cycle-averaged rate comes from the +# instantaneous table by angular quadrature over the field's polarisation ellipse; +# the population is the running trapezoid of that rate; two currents follow, the +# Drude drive and the loss, each windowed, projected and transformed as the field +# grid's two plasma streams are, and joined with -1/omega^2 and -i/omega. +# +# A scalar envelope's ellipse is a line: its major axis |E| and its minor/major ratio +# zero, so the cosine moment Mc is the rate and the loss current is 2 Mc E / |E|^2. + +"""The envelope plasma's workspace: the field plasma's fields where the shared paths +read them (the channels, the population tables, the projected and transformed +streams), complex, and the cycle quadrature's rules and spectral factors.""" +function envelope_plasma_workspace(c, host, nt, chunk, nm, nn) + host.flag("envelope_plasma") || return nothing + T, C = c.T, Complex{c.T} + by_node = c.free + columns = by_node ? 0 : nm + count = host.int("plasma_count") + suffix(k) = k == 1 ? "" : "_$k" + channels = [precise_table(c, host.array("plasma_coefficients" * suffix(k), Float64), + host.array("plasma_parameters" * suffix(k), Float64)) for k in 1:count] + fractions_all, peaks_all = dzeros(c, T, nn, count), dzeros(c, T, nn, count) + # The rules of orders 64, 128, 256 and 512 end to end; `levels` each one's end. + nodes, weights = host.array("envelope_rule_nodes", Float64), host.array("envelope_rule_weights", Float64) + ends = Tuple(cumsum(Int.(host.array("envelope_rule_orders", Int)))) + nf = c.nf + ( + envelope=Val(true), channels=channels, fractions_all=fractions_all, peaks_all=peaks_all, + channel=1, + coefficients=channels[1].coefficients, parameters=channels[1].parameters, + constant_tail=channels[1].constant_tail, inverse_edges=channels[1].inverse_edges, + inverse_tail=channels[1].inverse_tail, + dt=T(host.real("dt")), field_scale=T(c.scale), + rule_nodes=upload(c, T.(nodes)), rule_weights=upload(c, T.(weights)), levels=ends, + drude=upload(c, T.(host.array("envelope_drude", Float64))), + loss_factor=upload(c, C.(host.array("envelope_loss", ComplexF64))), + rate=dzeros(c, T, nt, chunk), exposure=dzeros(c, T, nt, chunk), + gated=dzeros(c, C, nt, chunk), edge=dzeros(c, C, nt, chunk), + projected=dzeros(c, C, nt, columns), edge_projected=dzeros(c, C, nt, columns), + coarse=dzeros(c, C, nt, columns), coarse_edge=dzeros(c, C, nt, columns), + spectrum=dzeros(c, C, nf, by_node ? chunk : nm), + edge_spectrum=dzeros(c, C, nf, by_node ? chunk : nm), + fractions=view(fractions_all, :, 1), peaks=view(peaks_all, :, 1), + ) +end + +"""A channel's table for `precise_rate`: the cubic at the state's precision, with its +constant term's tail, and each interval's inverse left edge as a head and a tail (the +mlx backend's DeviceRateTable).""" +function precise_table(c, coefficients, parameters) + T = c.T + n = size(coefficients, 2) + edges = exp.(parameters[4] .+ (0:n-1) .* parameters[5]) + inverse = inv.(edges) + (coefficients=upload(c, T.(coefficients)), parameters=parameters, + constant_tail=upload(c, T.(coefficients[4, :] .- Float64.(T.(coefficients[4, :])))), + inverse_edges=upload(c, T.(inverse)), inverse_tail=upload(c, T.(inverse .- Float64.(T.(inverse))))) +end + +"""The rate at a field inside the table's span, accurate to the state's precision: the +local coordinate `log1p(E / E_i - 1)` against the interval's left edge (a binary32 +`log E` would carry `|log E| u`, which the rate's slope multiplies), and the constant +term added by an exact two-sum and its tail, the rate `exp(hi) (1 + lo)` (the mlx +backend's `rate_at`). The cycle quadrature's refinement needs it: two rules agree to +2e-6, which a binary32 rate formed through `log E` misses by an order.""" +@inline function precise_rate(e, table, tail, inverse, inverse_tail, cap, origin, step) + k = clamp(unsafe_trunc(Int, floor((log(e) - origin) / step)) + 1, 1, size(table, 2)) + @inbounds begin + p = e * inverse[k] + error = fma(e, inverse[k], -p) + e * inverse_tail[k] + x = (p - 1) + error + u = 1 + x + coordinate = u == 1 ? x : log(u) * x / (u - 1) + constant = table[4, k] + remainder = ((table[1, k] * coordinate + table[2, k]) * coordinate + table[3, k]) * coordinate + head = constant + remainder + shifted = head - constant + low = (constant - (head - shifted)) + (remainder - shifted) + tail[k] + min(exp(head) * (1 + low), cap) + end +end + +"""`(sin, cos)` of an angle in [0, pi/2] by Taylor polynomials on [0, pi/4] (the +other half by the complement): about one ulp on every device, where a GPU's library +gives two or three (Metal), which near the table's low cutoff, where the rate is +steepest in the field, is more than the refinement's 2e-6 can take. Binary64 keeps the +library's.""" +@inline quadrant_sincos(theta::Float64) = sincos(theta) +@inline function quadrant_sincos(theta::T) where {T} + complement = theta > T(pi) / 4 + x = complement ? T(pi) / 2 - theta : theta + x2 = x * x + sine = x * evalpoly(x2, (T(1), T(-1 / 6), T(1 / 120), T(-1 / 5040), T(1 / 362880), + T(-1 / 39916800))) + cosine = evalpoly(x2, (T(1), T(-1 / 2), T(1 / 24), T(-1 / 720), T(1 / 40320), + T(-1 / 3628800), T(1 / 479001600))) + complement ? (cosine, sine) : (sine, cosine) +end + +is_envelope(p) = false +is_envelope(p::NamedTuple) = haskey(p, :envelope) + +"""One panel's two directional moments, `(upper - lower)/pi` times the rule's sums of +`W(major sqrt(d)) / d` against cos^2 and sin^2, `d = cos^2 + ratio^2 sin^2` (zero +ratio here). A panel's kind replaces the table's cutoffs: before the high cut the +ceiling rate, between the cuts the field held inside the table's span (binary32's +rounding of a cut angle cannot put a node across a cutoff). The sums are compensated.""" +@inline function panel_moments(major, lower, upper, ceiling, args, nodes, weights, first, last) + T = typeof(major) + half = (upper - lower) / 2 + s0, e0, s1, e1 = zero(T), zero(T), zero(T), zero(T) + table, tail, inverse, inverse_tail, low, high, cap, origin, step = args + @inbounds for i in first:last + theta = muladd(nodes[i] + 1, half, lower) + sine, cosine = quadrant_sincos(theta) + c2, s2 = cosine * cosine, sine * sine + rate = ceiling ? cap : + precise_rate(clamp(major * sqrt(c2), low, high), table, tail, inverse, inverse_tail, cap, origin, step) + r = rate / c2 + a, b = weights[i] * r * c2, weights[i] * r * s2 + # Neumaier's compensated sums. + t0 = s0 + a + e0 += abs(s0) >= abs(a) ? (s0 - t0) + a : (a - t0) + s0 + s0 = t0 + t1 = s1 + b + e1 += abs(s1) >= abs(b) ? (s1 - t1) + b : (b - t1) + s1 + s1 = t1 + end + width = (upper - lower) / T(pi) + (width * (s0 + e0), width * (s1 + e1)) +end + +"""The rule of `level`'s moments: split at the angles where `major cos(theta)` crosses +the table's cutoffs; the panel past the low cut contributes nothing.""" +@inline function rule_moments(major, args, nodes, weights, first, last) + T = typeof(major) + low, high = args[5], args[6] + quarter = T(pi) / 2 + # Past the low cut's angle the field is below the table: zero. + cut_low = low / major < 1 ? acos(low / major) : quarter + cut_high = high / major < 1 ? acos(high / major) : zero(T) + a0, a1 = panel_moments(major, zero(T), cut_high, true, args, nodes, weights, first, last) + b0, b1 = panel_moments(major, cut_high, cut_low, false, args, nodes, weights, first, last) + (a0 + b0, a1 + b1) +end + +"""The cosine moment of a scalar envelope of physical amplitude `major`, refined until +two successive rules agree within 2e-6 (floor 1e-30 s^-1); NaN where the 512-point rule +does not converge (the oracle's ConvergenceError: the step's norm refuses it).""" +@inline function cycle_rate(major, args, nodes, weights, levels) + T = typeof(major) + low = args[5] + major < low && return zero(T) + budget, floor = T(2e-6), T(1e-30) + previous = rule_moments(major, args, nodes, weights, 1, levels[1]) + for k in 2:length(levels) + current = rule_moments(major, args, nodes, weights, levels[k-1] + 1, levels[k]) + # The cosine moment only: at a scalar envelope's zero ratio the sine moment + # enters neither the rate nor the current, and its integrand (the rate times + # tan^2) is the one binary32 misses the budget on near the low cut. (The oracle + # asks both; a deliberate difference, recorded in julia/STATUS.md.) + if isfinite(current[1]) && abs(current[1] - previous[1]) <= budget * max(current[1], floor) + return current[1] + end + previous = current + end + T(NaN) +end + +"""The chunk's cycle-averaged rates and their running trapezoid, per channel.""" +function envelope_exposure!(q, nodes, c, count) + (; rate, exposure, dt, rule_nodes, rule_weights, levels) = q + T = typeof(dt) + args = (q.coefficients, q.constant_tail, q.inverse_edges, q.inverse_tail, + ntuple(k -> T(q.parameters[k]), 5)...) + scale = q.field_scale + nt = size(nodes, 1) + each!(c, nt, count) do t, n + @inbounds rate[t, n] = cycle_rate(scale * abs(nodes[t, n]), args, rule_nodes, rule_weights, levels) + end + half, none = dt / 2, zero(dt) + each!(c, nt, count) do t, n + @inbounds exposure[t, n] = t == 1 ? none : muladd(half, rate[t-1, n], half * rate[t, n]) + end + tally!(:scan) + scan_columns!(@view(exposure[:, 1:count]), c, none) + nothing +end + +"""The chunk's windowed drive and loss currents, every channel's summed.""" +function envelope_current!(p, nodes, c, count) + window = c.window + each_channel(p) do q, add + envelope_exposure!(q, nodes, c, count) + (; rate, exposure, gated, edge) = q + T = typeof(q.dt) + charge, potential = T(q.parameters[6]), T(q.parameters[7]) + k = q.channel + dens = stage_scalar(c, 2k, q.parameters[8]) + init = stage_scalar(c, 2k + 1, q.parameters[9]) + none = zero(eltype(gated)) + each!(c, size(nodes, 1), count) do t, n + @inbounds begin + density, initial = stage_value(dens), stage_value(init) + v, e = nodes[t, n], exposure[t, n] + survival = (1 - initial) * exp(-e) + fraction = initial + (1 - initial) * -expm1(-e) + squared = abs2(v) + drive = (charge * density * fraction) * v + loss = squared > 0 ? (potential * density * survival) * (2 * rate[t, n] / squared) * v : none + if add + gated[t, n] += window[t] * drive + edge[t, n] += window[t] * loss + else + gated[t, n] = window[t] * drive + edge[t, n] = window[t] * loss + end + end + end + end + nothing +end + +"""Add the drive's and the loss's spectra times -1/omega^2 and -i/omega (zero off the +supported band).""" +function add_envelope_spectra!(destination, p, c; coarse=false) + spectrum, edge_spectrum = p.spectrum, p.edge_spectrum + drude, loss, crop = p.drude, p.loss_factor, c.crop + each!(c, length(crop), size(destination, 2)) do f, m + @inbounds begin + k = crop[f] + destination[k, m] += drude[f] * spectrum[k, m] + loss[f] * edge_spectrum[k, m] + end + end +end + +"""Fresh populations at an observation: each node's final fraction and peak rate.""" +function envelope_populations!(q, nodes, c, first, count) + envelope_exposure!(q, nodes, c, count) + (; rate, exposure, fractions, peaks) = q + T = typeof(q.dt) + initial, none = T(q.parameters[9]), zero(q.dt) + nt = size(nodes, 1) + each!(c, count, 1) do n, _ + @inbounds begin + peak = none + for t in 1:nt + peak = max(peak, rate[t, n]) + end + e = exposure[nt, n] + fractions[first+n-1] = initial + (1 - initial) * -expm1(-e) + peaks[first+n-1] = peak + end + end + zeros(6) +end + +"""Whether the last source left a non-converged sample (NaN) in a channel's rates: the +adapter asks only after a nonfinite norm, to raise the oracle's ConvergenceError.""" +function envelope_failed(engine) + p = engine.work.plasma + p === nothing || !is_envelope(p) ? false : any(isnan, Array(p.rate)) +end diff --git a/julia/src/free.jl b/julia/src/free.jl new file mode 100644 index 000000000..f39c86024 --- /dev/null +++ b/julia/src/free.jl @@ -0,0 +1,398 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Cartesian and line free space: the state is (n_omega, n_x n_y) in the transverse +# spectral basis; the response is evaluated in physical space, chunk by chunk of +# columns, and the operator is formed per element from separable tables. + +function create_free(c, host) + c = common_tables(c, host) + T, C = c.T, Complex{c.T} + shape = Tuple(Int.(host.value("spatial_shape"))) + nw, nm, nt, nf = length(host.array("crop", Int)), prod(shape), c.nt, c.nf + spatial_rate = host.array("spatial_rate", Float64) + # An exactly absent additive loss omits its transforms; the accepted-step split + # and the diagonal spectral loss are separate. + in_stage = any(!iszero, spatial_rate) || (!c.split && any(!iszero, c.rate)) + nc = length(c.coarse_rate) + # Both inverse transforms are unnormalised; their 1/(nt n_x n_y) goes into the + # factor that forms the physical field from them. + scale = inv(T(nt) * T(nm)) + # The separable operator stays binary64 at either precision: the longitudinal root's + # compensated subtraction decides its branch near grazing (free_element). + R64, C64 = Float64, ComplexF64 + separable = ( + k_squared=host.array("k_squared", C64), k_squared_low=host.array("k_squared_low", C64), + kperp_sq=host.array("kperp_sq", R64), kperp_sq_low=host.array("kperp_sq_low", R64), + frame=host.array("frame", R64), spectral_rate=host.array("spectral_rate", R64), + prefactor_numerator=host.array("prefactor_numerator", C64), + prefactor_clamped=host.array("prefactor_clamped", C64), + active=host.array("active", Bool), kperp_rate=host.array("kperp_rate", R64), + evanescent_rate=host.real("evanescent_rate"), + ) + # In binary64 the tables go to the device and each element is formed where it is + # read. Where the wide type is a double-float, the elements are formed once on the + # host in binary64 (the compensated subtraction and the root need it) and held as + # a rate table in the wide type and a prefactor at the state's precision. + # On a GPU in binary64 too: each source re-formed every element's prefactor, a root + # and a division (binary64 at an A40's 1/64 rate, about half a Cartesian window). + op = wide_eltype(c) === Float64 && oncpu(c) ? + map(v -> v isa Array ? upload(c, v) : v, separable) : free_tables(c, separable, nw, nm) + # The exponential Adams trial reads every element's rate (its phi functions take + # the step's exponent): the host-formed table, the same binary64 values. + adams = host.has("adams_order") && host.int("adams_order") > 0 + linear = !adams ? upload(c, widen_host(wide_eltype(c), zeros(ComplexF64, 0, 0))) : + haskey(op, :rate) ? op.rate : free_tables(c, separable, nw, nm).rate + c = merge(c, (linear=linear, + spatial_shape=shape, op=op, field_scale=T(host.real("pad_scale")) * scale, + absorber_scale=T(-0.5) * scale, spatial_rate=upload(c, T.(spatial_rate)), + temporal_rate=upload(c, T.(c.split ? zero(c.rate) : c.rate)), in_stage=in_stage, + coarse_rate=upload(c, T.(c.coarse_rate)), nc=nc, embedded=false, + )) + chunk = node_chunk(c, host.int("chunk"), nm, nt) + R = c.envelope ? C : T + stages = c.low_storage ? 0 : 7 + physical = dzeros(c, C, nw, nm) + spatial = reshape(physical, nw, shape...) + fine, modal = dzeros(c, C, nf, chunk), dzeros(c, R, nt, chunk) + analytic = dzeros(c, C, nt, chunk) + coarse, coarse_spec = dzeros(c, R, nc, chunk), dzeros(c, C, nw, chunk) + planes = (threads=c.transverse_fft_threads, batch=1) + # On a GPU the projected polarisation and the plasma's two currents are column + # blocks of one buffer, transformed together (three transforms a source were one + # each, through the device's FFT library between the engine's kernels). + plasma = plasma_workspace(c, host, nt, chunk, chunk, nm) + projected = dzeros(c, R, nt, chunk) + pack = nothing + if !oncpu(c) && plasma !== nothing && !c.envelope + pack_in, pack_out = dzeros(c, R, nt, 3chunk), dzeros(c, C, nf, 3chunk) + block(a, j) = view(a, :, (j-1)*chunk+1:j*chunk) + projected, fine = block(pack_in, 1), block(pack_out, 1) + plasma = merge(plasma, (gated=block(pack_in, 2), edge=block(pack_in, 3), + spectrum=block(pack_out, 2), edge_spectrum=block(pack_out, 3))) + pack = (input=pack_in, output=pack_out, forward=plan(c, plan_rfft, pack_in, 1)) + end + work = ( + adams=adams_workspace(c, host, nw, nm), path=nothing, raman=raman_workspace(c, host, nt, chunk), monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), held_state=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), + plasma=plasma, pack=pack, + y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), + source=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), + stages=dzeros(c, C, nw, nm, stages), + forward=dzeros(c, C, nw, nm, 1), inverse=dzeros(c, C, nw, nm, c.low_storage ? 0 : 1), + physical=physical, loss=dzeros(c, C, in_stage ? nw : 0, in_stage ? nm : 0), + fine=fine, modal=modal, projected=projected, analytic=analytic, + absorber=dzeros(c, R, nt, chunk), absorber_spec=similar(fine), coarse=coarse, coarse_spec=coarse_spec, + spatial_inverse=transverse_plan(c, plan_bfft!, spatial, planes), + spatial_forward=transverse_plan(c, plan_fft!, spatial, planes), + inverse_plan=c.envelope ? plan(c, plan_bfft, fine, 1) : plan(c, plan_brfft, fine, nt, 1), + forward_plan=c.envelope ? plan(c, plan_fft, modal, 1) : plan(c, plan_rfft, modal, 1), + analytic_forward=plan(c, plan_fft!, analytic, 1), analytic_inverse=plan(c, plan_bfft!, analytic, 1), + coarse_inverse=c.envelope ? plan(c, plan_bfft, coarse_spec, 1) : plan(c, plan_brfft, coarse_spec, nc, 1), + coarse_forward=c.envelope ? plan(c, plan_fft, coarse, 1) : plan(c, plan_rfft, coarse, 1), + ) + Engine(c, work, false, 0, NaN, c.factor, NaN, false, 1.0, 0) +end + +# For an exactly real squared longitudinal wave number the principal root is sqrt(x) +# for x > 0 and i sqrt(-x) for x < 0, keeping the imaginary signed zero; a lossy or +# nonfinite input takes the library's complex root. No near-zero cutoff. +@inline function free_root(q) + x, y = real(q), imag(q) + if iszero(y) && isfinite(x) + x > 0 && return complex(sqrt(x), y) + x < 0 && return complex(zero(x), copysign(sqrt(-x), y)) + return complex(zero(x), y) + end + sqrt(q) +end + +"""The element's linear rate and its prefactor, from the separable tables. + +The compensated subtraction that forms `q` keeps translate.spatial.longitudinal_root's +order: near grazing the residual decides the branch, so no reassociation here. +""" +@inline function free_element(op, f, m) + @inbounds begin + q = (op.k_squared[f] - op.kperp_sq[m]) + (op.k_squared_low[f] - op.kperp_sq_low[m]) + root = free_root(q) + propagating = real(q) > 0 + attenuation = propagating ? imag(root) : min(abs(imag(root)), op.evanescent_rate) + live = op.active[f] + rate = live ? complex(-attenuation - op.kperp_rate[m] / 2, -(real(root) - op.frame[f])) : + zero(root) + prefactor = propagating ? op.prefactor_numerator[f] / real(root) : op.prefactor_clamped[f] + return rate - op.spectral_rate[f] / 2, live ? prefactor : zero(prefactor) + end +end + +"""The element's rate and prefactor, read from tables formed on the host.""" +@inline free_element(op::NamedTuple{(:rate, :prefactor)}, f, m) = + @inbounds (op.rate[f, m], op.prefactor[f, m]) + +"""Every element's rate (in the wide type) and prefactor (at the state's precision), +formed on the host in binary64 by `free_element` from the separable tables.""" +function free_tables(c, separable, nw, nm) + rate = Matrix{ComplexF64}(undef, nw, nm) + prefactor = Matrix{ComplexF64}(undef, nw, nm) + Threads.@threads for m in 1:nm + for f in 1:nw + rate[f, m], prefactor[f, m] = free_element(separable, f, m) + end + end + (rate=upload(c, widen_host(wide_eltype(c), rate)), prefactor=upload(c, Complex{c.T}.(prefactor))) +end + +"""Form the propagator pair of one distance in slot one; return the slot.""" +function free_propagators!(engine, h) + engine.propagator_dz == h && return 1 + c, w = engine.config, engine.work + (; forward, inverse) = w + if h == 0 + # The zero-distance stage is exactly the identity. + fill!(forward, 1) + fill!(inverse, 1) + elseif haskey(c.op, :rate) + # The double-float exponent's pair shares one reduced phasor (wide_exp_pair). + # (Names of their own: a captured name assigned in two branches is boxed.) + rates, pair, length = c.op.rate, !c.low_storage, wide_value(c, Float64(h)) + each!(c, size(forward, 1), size(forward, 2)) do f, m + @inbounds begin + there, back = wide_exp_pair(length * rates[f, m]) + forward[f, m, 1] = there + pair && (inverse[f, m, 1] = back) + end + end + else + op, both, distance = c.op, !c.low_storage, Float64(h) + each!(c, size(forward, 1), size(forward, 2)) do f, m + @inbounds begin + exponent = distance * first(free_element(op, f, m)) + # Both signs share exact trigonometric inputs, as in the compiled seam. + scale = exp(real(exponent)) + sine, cosine = sincos(imag(exponent)) + forward[f, m, 1] = scale * complex(cosine, sine) + both && (inverse[f, m, 1] = complex(cosine, -sine) / scale) + end + end + end + engine.propagator_dz = h + 1 +end + +"""The Kerr polarisation of the scaled field in one pass: the envelope's, with its +third-harmonic term where one is compiled, or the field grid's.""" +function fused_kerr!(projected, modal, c, scale, factor, a, window) + if c.envelope + h, carrier = factor * c.harmonic, c.carrier + harmonic = !iszero(h) + each!(c, size(modal)...) do t, m + @inbounds begin + v = scale * modal[t, m] + response = factor * a * abs2(v) * v + if harmonic + response += h * carrier[t] * (v * v) * v + end + projected[t, m] = response * window[t] + end + end + else + each!(c, size(modal)...) do t, m + @inbounds projected[t, m] = polarization(scale * modal[t, m], factor, a) * window[t] + end + end +end + +transverse!(a, plan, c) = (plan * reshape(a, size(a, 1), c.spatial_shape...); nothing) + +"""A GPU's transverse transform through a transverse-first copy: the frequency-first +state's planes are strided by n_omega, and cuFFT's strided batched 2D transform at +512 x 192 x 192 took 16.2 ms on an A40 against 4.8 for contiguous planes. The planes +are transposed out, transformed contiguously and transposed back: on an A40 0.92 on +`kerr_beam_192` and 0.89 on `line` in binary64. Metal's MPSGraph takes the strided +planes well (the copies made it 1.10 and 1.09), so a device extension asks for it +(`transposed_planes`). `SOLPROP_JULIA_TRANSPOSE=0` keeps the strided plan, for A/Bs.""" +transposed_planes(backend) = get(ENV, "SOLPROP_JULIA_TRANSPOSE", "") == "1" +struct Transposed{P,B} + plan::P + buffer::B +end +function transverse_plan(c, kind, spatial, planes) + dims = Tuple(2:ndims(spatial)) + (oncpu(c) || !transposed_planes(c.backend) || get(ENV, "SOLPROP_JULIA_TRANSPOSE", "1") == "0") && + return plan(c, kind, spatial, dims; planes...) + buffer = similar(spatial, size(spatial)[2:end]..., size(spatial, 1)) + Transposed(kind(buffer, Tuple(1:ndims(spatial)-1)), buffer) +end +function transverse!(a, p::Transposed, c) + # The state (n_omega, n_x n_y) and the planes (n_x n_y, n_omega) are each other's + # transposes as matrices. + nw = size(a, 1) + planes = reshape(p.buffer, :, nw) + state = reshape(a, nw, :) + transpose_device!(planes, state, c) + p.plan * p.buffer + transpose_device!(state, planes, c) + nothing +end + +"""Copy columns `first:first+count-1` of `physical` into the fine spectrum.""" +function scatter_columns!(fine, physical, first, count, c) + uncrop = c.uncrop + each!(c, size(fine)...) do k, m + @inbounds begin + f = uncrop[k] + fine[k, m] = f == 0 || m > count ? zero(eltype(fine)) : physical[f, first+m-1] + end + end +end + +function source_free!(engine, lab) + c, w = engine.config, engine.work + (; physical, fine, modal, projected, analytic, loss) = w + nm = size(lab, 2) + chunk = size(modal, 2) + pool_copy!(physical, lab, c) + transverse!(physical, w.spatial_inverse, c) + # Transverse inversion first: a transverse spectral column alone is not the + # spectrum of a real temporal field. + scale, window, a = c.field_scale, c.window, c.analytic_factor + T = real_type(engine) + factor = T(c.factor) + for first in 1:chunk:nm + count = min(chunk, nm - first + 1) + scatter_columns!(fine, physical, first, count, c) + mul!(modal, w.inverse_plan, fine) + raman = w.raman + if w.plasma === nothing && raman === nothing && !c.analytic + # Kerr alone: the field and its polarisation in one pass, as a Cartesian + # state is large (two passes made a 192 x 192 window a quarter slower). + fused_kerr!(projected, modal, c, scale, factor, a, window) + else + # The physical field, which the plasma reads, then the responses in place, as + # a modal source's nodes take them (`node_response!`). + each!(c, size(modal)...) do t, m + @inbounds projected[t, m] = scale * modal[t, m] + end + w.plasma === nothing || plasma_current!(w.plasma, projected, c, count) + if c.envelope + raman === nothing || raman_drive!(raman, projected, projected, c, chunk) + nonlinear_envelope!(projected, c, factor, raman, chunk) + elseif c.analytic || (raman !== nothing && !raman.thg) + analytic_signal!(analytic, projected, w.analytic_forward, w.analytic_inverse, c, chunk) + raman === nothing || raman_drive!(raman, projected, analytic, c, chunk) + nonlinear_nodes!(projected, c.analytic ? analytic : projected, c, factor, raman, chunk) + else + raman === nothing || raman_drive!(raman, projected, projected, c, chunk) + nonlinear_nodes!(projected, projected, c, factor, raman, chunk) + end + end + # The held-current polarisation joins before the transverse forward transform, + # as the reference Cartesian source does. + if w.pack !== nothing + mul!(w.pack.output, w.pack.forward, w.pack.input) + add_plasma_spectra!(fine, w.plasma, c) + else + mul!(fine, w.forward_plan, projected) + w.plasma === nothing || add_plasma!(fine, w.plasma, w.forward_plan, c; direct=true) + end + c.in_stage && free_absorber!(w, c, first, count) + gather_columns!(physical, fine, c.in_stage ? loss : nothing, w.absorber_spec, first, count, c) + end + transverse!(physical, w.spatial_forward, c) + c.in_stage && transverse!(loss, w.spatial_forward, c) + (; source) = w + (; op, omega_window, mask) = c + live = c.in_stage + extra = live ? loss : physical + each!(c, size(source)...) do f, m + @inbounds begin + prefactor = oftype(physical[f, m], last(free_element(op, f, m))) + value = prefactor * omega_window[f] * physical[f, m] + if live && mask[f] + value += extra[f, m] + end + source[f, m] = value + end + end + engine.calls += 1 + nothing +end + +"""The in-stage loss of a chunk's columns: their spatial collar and, unsplit, time's.""" +function free_absorber!(w, c, first, count) + (; absorber, modal) = w + spatial, temporal, scale = c.spatial_rate, c.temporal_rate, c.absorber_scale + each!(c, size(absorber)...) do t, m + @inbounds begin + rate = (m <= count ? spatial[first+m-1] : zero(scale)) + temporal[t] + absorber[t, m] = scale * rate * modal[t, m] + end + end + mul!(w.absorber_spec, w.forward_plan, absorber) +end + +function gather_columns!(physical, fine, loss, absorber_spec, first, count, c) + crop = c.crop + live = loss !== nothing + target = live ? loss : physical + each!(c, size(physical, 1), count) do f, m + @inbounds begin + k = crop[f] + physical[f, first+m-1] = fine[k, m] + live && (target[f, first+m-1] = absorber_spec[k, m]) + end + end +end + +function split_free!(engine, dz, monitored) + c, w = engine.config, engine.work + (; physical, coarse, coarse_spec) = w + pool_copy!(physical, w.candidate, c) + transverse!(physical, w.spatial_inverse, c) + chunk, nm, nw = size(coarse, 2), size(physical, 2), size(physical, 1) + T = real_type(engine) + rate, half = c.coarse_rate, T(-0.5 * dz) + # Both unnormalised inverses' 1/(nc n_x n_y) is folded into the collar's factor. + inverse = inv(T(c.nc) * T(nm)) + monitored && fill!(w.monitor.split, 0) + factor = collar_factor(rate, half, inverse, c) + for first in 1:chunk:nm + count = min(chunk, nm - first + 1) + columns_into!(coarse_spec, physical, first, count, c) + mul!(coarse, w.coarse_inverse, coarse_spec) + monitored && add_power!(w.monitor.split, coarse, w.monitor.columns, first, count, c) + each!(c, size(coarse)...) do t, m + @inbounds coarse[t, m] *= factor[t] + end + mul!(coarse_spec, w.coarse_forward, coarse) + each!(c, nw, count) do f, m + @inbounds physical[f, first+m-1] = coarse_spec[f, m] + end + end + transverse!(physical, w.spatial_forward, c) + pool_copy!(w.candidate, physical, c) + nothing +end + +function population_free_snapshot(engine, input) + c, w = engine.config, engine.work + p = w.plasma + (; physical, fine, modal, projected) = w + pool_copy!(physical, scaled_input(engine, input), c) + transverse!(physical, w.spatial_inverse, c) + chunk, nm = size(modal, 2), size(physical, 2) + scale = c.field_scale + maxima = zeros(6) + for first in 1:chunk:nm + count = min(chunk, nm - first + 1) + scatter_columns!(fine, physical, first, count, c) + mul!(modal, w.inverse_plan, fine) + each!(c, size(modal)...) do t, m + @inbounds projected[t, m] = scale * modal[t, m] + end + each_channel(p) do q, _ + maxima .= max.(maxima, population_parts!(q, projected, c, first, count)) + end + end + (channel_rows(p.fractions_all), channel_rows(p.peaks_all), maxima) +end diff --git a/julia/src/helpers.jl b/julia/src/helpers.jl new file mode 100644 index 000000000..7acc8f23b --- /dev/null +++ b/julia/src/helpers.jl @@ -0,0 +1,177 @@ +# The shared per-stage and per-step evaluations (`solprop._helpers`), and an exponential +# Adams trial's coefficient tables. Each is a transcription of its Python form with the +# same IEEE operations in the same order (Julia contracts nothing without being asked), +# so the values agree with numpy_ref's and native's bit for bit. + +"""`chebyshev._clenshaw_points`: a table's rows at several positions, written to `out`. + +`c` is (n_intervals, n_terms, n_values) and `out` (n_points, n_values), NumPy arrays +seen through PythonCall. Returns the first position outside `[lower, upper]`, zero +based, or -1. +""" +function clenshaw_points!(z, edges, lower, upper, c, out) + n, m = size(c, 2), size(c, 3) + last = length(edges) - 2 # the last interval, zero based + @inbounds for p in eachindex(z) + zp = z[p] + (zp < lower || zp > upper) && return p - 1 + if zp != zp # NaN sorts last, as in `searchsorted` + k = last + else + # `searchsorted(edges, zp, side="right") - 1`, clamped to an interval. + low, high = 0, length(edges) + while low < high + middle = (low + high) ÷ 2 + if edges[middle+1] <= zp + low = middle + 1 + else + high = middle + end + end + k = min(max(low - 1, 0), last) + end + lo, hi = edges[k+1], edges[k+2] + xp = (2.0 * zp - lo - hi) / (hi - lo) + if n == 1 + for j in 1:m + out[p, j] = c[k+1, 1, j] + 0.0 * xp + end + elseif n == 2 + for j in 1:m + out[p, j] = c[k+1, 1, j] + c[k+1, 2, j] * xp + end + else + x2 = 2 * xp + for j in 1:m + c0, c1 = c[k+1, n-1, j], c[k+1, n, j] + for i in 3:n + tmp = c0 + c0 = c[k+1, n-i+1, j] - c1 + c1 = tmp + c1 * x2 + end + out[p, j] = c0 + c1 * xp + end + end + end + -1 +end + +"""`multistep._basis_rows`: the Lagrange basis on `points`, written to `rows` (its +coefficients, unless integrating) or `weights` (its integrals from 0 to `upper`).""" +function basis_rows!(points, upper, integrate, rows, weights) + n = length(points) + coefficients, product = zeros(n), zeros(n) + @inbounds for index in 1:n + node = points[index] + filled = 1 + coefficients[1] = 1.0 + denominator = 1.0 + for other in 1:n + other == index && continue + root = points[other] + product[1] = 0.0 + for power in 1:filled + product[power+1] = coefficients[power] + end + for power in 1:filled + product[power] -= root * coefficients[power] + end + filled += 1 + for power in 1:filled + coefficients[power] = product[power] + end + denominator *= node - root + end + if integrate + integral = 0.0 + for power in filled:-1:1 + integral = (integral + coefficients[power] / power) * upper + end + weights[index] = integral / denominator + else + for power in 1:filled + rows[index, power] = coefficients[power] / denominator + end + end + end + nothing +end + +"""`stepper.multistep.lagrange_coefficients`, unchecked: (n, n).""" +function lagrange(points) + rows = zeros(length(points), length(points)) + basis_rows!(points, 1.0, false, rows, nothing) + rows +end + +"""`stepper.multistep.integrated_weights` on `[0, 1]`, unchecked: (n,).""" +function integrated(points) + weights = zeros(length(points)) + basis_rows!(points, 1.0, true, nothing, weights) + weights +end + +"""`backends.multistep.factored_defect_rows`, into `rows` ((count, 2 width), zeroed).""" +function factored_defect_rows!(rows, nodes, orders, width) + for (index, order) in enumerate(orders) + points = [1.0; nodes[1:order]] + for (t, node) in enumerate(points) + denominator = 1.0 + for (s, other) in enumerate(points) + s != t && (denominator *= node - other) + end + rows[index, t] = 1.0 / denominator + end + coefficients = [1.0] + for root in nodes[1:order] + product = [0.0; coefficients] + for (power, value) in enumerate(coefficients) + product[power] -= root * value + end + coefficients = product + end + rows[index, width+1:width+order+1] .= coefficients + end + rows +end + +"""An exponential trial's tables (`backends.multistep.trial_tables`) written straight +into the engine's host tables, then copied to the device: `nodes` newest first, the +step's `order` and the `orders` scored, the step's own first; `slots` the history's +zero-based slots and `rate` the operator's rate weights (compensated only).""" +function configure_adams_nodes!(engine, nodes, order, orders, slots, rate) + a = engine.work.adams + h = a.host + nodes, orders = Vector{Float64}(nodes), Vector{Int}(orders) + width, count = 1 + maximum(orders), length(orders) + a.sizes .= (order, width, count) + h.predictor[1:order, 1:order] .= lagrange(nodes[1:order]) + h.corrector[1:width, 1:width] .= 0.0 + h.corrector[1:order+1, 1:order+1] .= lagrange([1.0; nodes[1:order]]) + h.defects[1:count, 1:2width] .= 0.0 + factored_defect_rows!(view(h.defects, 1:count, 1:2width), nodes, orders, width) + incoming = Vector{Int}(slots) + h.slots[1:width-1] .= view(incoming, 1:width-1) .+ 1 + if a.compensated + h.spans[1:width-1] .= 1.0 .- view(nodes, 1:width-1) + # Each count's pair once: the step's own is also its defect's. + weights = Dict(n => (integrated(nodes[1:n]), integrated([1.0; nodes[1:n]])) + for n in unique([order; orders])) + h.cdefects[1:count, 1:width] .= 0.0 + for (index, scored) in enumerate(orders) + predicted, through = weights[scored] + h.cdefects[index, 1:scored+1] .= through + h.cdefects[index, 2:scored+1] .-= predicted + end + predictor, corrector = weights[order] + h.cpredictor[1:order] .= predictor + h.ccorrector[1:order+1] .= corrector + h.rate .= Vector{Float64}(rate) + end + upload_tables!(a) + nothing +end + +const clenshaw_points_b = clenshaw_points! +const basis_rows_b = basis_rows! +const configure_adams_nodes_b = configure_adams_nodes! diff --git a/julia/src/launch.jl b/julia/src/launch.jl new file mode 100644 index 000000000..8431b6434 --- /dev/null +++ b/julia/src/launch.jl @@ -0,0 +1,671 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# The device layer: everything that differs between a CPU and a GPU is here. + +"""Read the settings a Python dict carries, once, at construction.""" +function HostInput(input) + has(key) = haskey(input, key) + (has=has, int=key -> Int(input[key]), real=key -> Float64(input[key]), + flag=key -> has(key) && Bool(input[key]), string=key -> String(input[key]), + array=(key, T) -> Array{T}(input[key]), value=key -> input[key]) +end + +device_backend(::Val{:cpu}) = KA.CPU() +device_backend(::Val{D}) where {D} = + throw(ArgumentError("device $D needs its package loaded first (SOLPROP_JULIA_DEVICE)")) +device_label(::KA.CPU) = "cpu" +oncpu(c) = c.backend isa KA.CPU + +"""Put a host array on the engine's device, owning it on the CPU too.""" +upload(::KA.CPU, a::Array) = a +upload(backend, a::Array) = (tally!(:upload); copyto!(KA.allocate(backend, eltype(a), size(a)), a)) +upload(c::NamedTuple, a::Array) = upload(c.backend, a) +dzeros(c, T, dims...) = KA.zeros(c.backend, T, dims...) + +# Development counters (SOLPROP_JULIA_COUNT=1 when the module loads): a device's kernel +# launches, the values the host waits for, uploads, products and scratch allocations, +# by kind. Off, `tally!` costs one branch. +const COUNT = Ref(false) +const COUNTS = Dict{Symbol,Int}() +@inline tally!(kind::Symbol, n=1) = (COUNT[] && (COUNTS[kind] = get(COUNTS, kind, 0) + n); nothing) +counts() = Dict(String(k) => v for (k, v) in COUNTS) +clear_counts() = (empty!(COUNTS); nothing) + +# Below this many samples one pass is faster on one thread than split over tasks +# (julia/bench/launch.jl: a Kerr pass over 10240 x 4 takes 8.5 us on one thread of the +# Xeon, 10.5 us on four). +const PARALLEL_SAMPLES = 65536 + +"""Call `f(t, m)` for every sample of an `nt` x `nm` column-major array. + +On a CPU each task takes whole columns, or pieces of one when there are fewer columns +than tasks, and runs a contiguous `@simd` loop over its rows: an index divide per +sample costs a factor of ten (julia/bench/launch.jl). The tasks are Polyester's, +whose threads wait spinning: a pass between serial work costs 2.2 us on four Xeon +cores where a spawned task costs 10 and `Threads.@threads` 110 (10240 x 4; 13, 49 and +147 us over 1728 x 128). On a GPU each sample is a thread. +""" +@inline function each!(f::F, c, nt::Integer, nm::Integer; heavy=false) where {F} + CHECK[] && check_body(F) + each_on!(f, c.backend, c.tasks, Int(nt), Int(nm), heavy) +end + +# SOLPROP_JULIA_CHECK=1: refuse a body a GPU kernel could not take, on any device. A +# captured type, box or union is found on a CPU run instead of on the first GPU one. +const CHECK = Ref(false) +function check_body(::Type{F}) where {F} + for T in fieldtypes(F) + (T <: Type || T === Core.Box || T isa Union || !isconcretetype(T)) && + throw(ArgumentError("kernel body $F captures $T, which a GPU kernel cannot take")) + (T <: Function || T <: Tuple || T <: NamedTuple) && check_body(T) + end +end + +function each_on!(f::F, ::KA.CPU, tasks, nt, nm, heavy) where {F} + pieces, rows = tiling(tasks, nt, nm, heavy) + if pieces * nm == 1 + @inbounds @simd for t in 1:nt + @inline f(t, 1) + end + return nothing + end + @batch for k in 1:pieces*nm + m = (k - 1) ÷ pieces + 1 + first = (k - (m - 1) * pieces - 1) * rows + 1 + @inbounds @simd for t in first:min(first + rows - 1, nt) + @inline f(t, m) + end + end + nothing +end + +"""Split `nt` x `nm` samples into column pieces: one task's worth each. + +A `heavy` body (tens of operations a sample, such as the phi functions) is worth +splitting from a few hundred samples. +""" +function tiling(tasks, nt, nm, heavy=false) + # A heavy body (the Adams trial's phi functions, about 100 ns an element) pays for a + # task from a few hundred elements: argon's 1601 ran serially on 16 threads. + least = heavy ? 256 : PARALLEL_SAMPLES + if tasks == 1 || nt * nm < least + return 1, nt + end + nm >= tasks && return 1, nt + pieces = min(cld(tasks, nm), cld(nt * nm, least ÷ 4)) + pieces, cld(nt, pieces) +end + +# The body inlined at the call (as the CPU loops do): left to the inliner, a body of a +# few operations became a device call per sample, its arguments through local memory, +# 9 times slower in binary64 and 20 in binary32 on an A40 (a 1.08 M-sample cube, 296 +# against 33 us; DMOG `scripts/each_cost3.jl`). +KA.@kernel inbounds = true function each_kernel!(f) + t, m = KA.@index(Global, NTuple) + @inline f(t, m) +end +function each_on!(f::F, backend, tasks, nt, nm, heavy) where {F} + tally!(:launch) + if KERNEL_TIMING[] + SYNCHRONIZE[]() + started = time_ns() + each_kernel!(backend, (256, 1))(f; ndrange=(nt, nm)) + SYNCHRONIZE[]() + time_kernel!(F, nt * nm, time_ns() - started) + return nothing + end + each_kernel!(backend, (256, 1))(f; ndrange=(nt, nm)) + nothing +end + +# SOLPROP_JULIA_KERNEL_TIMING=1: each GPU pass timed alone (synchronised around it), +# by the body's name and size: which closure a profiler's generic kernel is. +const KERNEL_TIMING = Ref(false) +const KERNEL_TIMES = Dict{String,Tuple{Int,Float64,Int}}() +function time_kernel!(::Type{F}, size, elapsed) where {F} + name = replace(string(nameof(F)), r"#+" => "#") + count, total, _ = get(KERNEL_TIMES, name, (0, 0.0, size)) + KERNEL_TIMES[name] = (count + 1, total + elapsed * 1e-9, size) +end +kernel_timings() = Dict(k => collect(v) for (k, v) in KERNEL_TIMES) +clear_kernel_timings() = empty!(KERNEL_TIMES) + +"""`out = transpose(inp)` for two device matrices, through 32 x 32 tiles in local memory: +both the reads and the writes coalesced. GPUArrays' `permutedims!` took 2.65 ms to +transpose a 384 x 36864 binary64 complex state on an A40, three times the copy's.""" +function transpose_device!(out, inp, c) + n1, n2 = size(inp) + tally!(:transpose) + transpose_kernel!(c.backend, (32, 32))(out, inp; ndrange=(cld(n1, 32) * 32, cld(n2, 32) * 32)) + out +end +KA.@kernel inbounds = true function transpose_kernel!(out, @Const(inp)) + ti, tj = KA.@index(Local, NTuple) + bi, bj = KA.@index(Group, NTuple) + tile = KA.@localmem eltype(out) (33, 32) + n1, n2 = size(inp) + i, j = (bi - 1) * 32 + ti, (bj - 1) * 32 + tj + if i <= n1 && j <= n2 + tile[ti, tj] = inp[i, j] + end + KA.@synchronize + # The tile's transpose, to the block on the other side of the diagonal. + p, q = (bj - 1) * 32 + ti, (bi - 1) * 32 + tj + if p <= n2 && q <= n1 + out[p, q] = tile[tj, ti] + end +end + +"""A device scratch array the engine keeps (`c.scratch`), by its use, type and shape: a +GPU's pool allocations a trial were dozens.""" +scratch(c, use::Symbol, T, dims...) = + get!(() -> (tally!(:scratch_alloc); KA.allocate(c.backend, T, dims...)), c.scratch, (use, T, dims)) + +"""`f(t, m)` at every sample, into a device scratch matrix of `out`'s element type, for +a device reduction over its rows or columns.""" +function reduce_terms(f::F, c, out, nt, nm; use=:terms) where {F} + scratch = SolpropJulia.scratch(c, use, eltype(out), nt, nm) + each!(c, nt, nm) do t, m + @inbounds scratch[t, m] = @inline f(t, m) + end + scratch +end + +"""Call `f(m)` for each of `nm` columns, whose body runs sequentially down one.""" +function each_column!(f::F, c, nm::Integer) where {F} + CHECK[] && check_body(F) + if oncpu(c) + @batch for m in 1:Int(nm) + @inline f(m) + end + else + tally!(:launch) + AK.foreachindex(f, 1:Int(nm); backend=c.backend, block_size=64) + end + nothing +end + +"""Set `out[t]` to the sum over `m` of `f(t, m)`: a reduction across columns. + +Each task (CPU) or thread (GPU) owns a block of rows, so no two write one sum. +""" +function rowsum!(f::F, c, out, nt::Integer, nm::Integer) where {F} + nt, nm = Int(nt), Int(nm) + CHECK[] && check_body(F) + if oncpu(c) + rows = max(256, cld(nt, c.tasks)) + @batch for b in 1:cld(nt, rows) + r = (b-1)*rows+1:min(b * rows, nt) + for m in 1:nm + @inbounds @simd for t in r + out[t] += f(t, m) + end + end + end + else + # A thread a row looped over every column (36864 for a Cartesian plane): the + # terms fill a scratch matrix in parallel and the device's reduction sums it. + scratch = reduce_terms(f, c, out, nt, nm) + total = SolpropJulia.scratch(c, :rows, eltype(out), nt, 1) + tally!(:launch, 2) + sum!(total, scratch) + out .+= vec(total) + end + nothing +end + +"""Return `op` folded over `f(t, m)` for every sample, starting from `neutral`. + +`op` must be associative and commutative: the order is the tiling's (CPU) or the +reduction tree's (GPU), and differs with the width (SEP 25 bounds it, not bits). +""" +function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=false) where {F,O} + nt, nm = Int(nt), Int(nm) + CHECK[] && check_body(F) + if oncpu(c) + pieces, rows = tiling(c.tasks, nt, nm, heavy) + partials = fill(neutral, pieces * nm) + @batch for k in 1:pieces*nm + m = (k - 1) ÷ pieces + 1 + first = (k - (m - 1) * pieces - 1) * rows + 1 + value = neutral + @inbounds for t in first:min(first + rows - 1, nt) + value = op(value, f(t, m)) + end + @inbounds partials[k] = value + end + return foldl(op, partials; init=neutral) + end + tally!(:readback) + # The bodies run as an elementwise kernel into scratch, inlined (`each_kernel!`), and + # only the values reduce: inside AK's reduction the body was a device call per + # element, and a heavy one got several elements a thread (six blocks for rdw's + # 10244, its predictor 539 us a trial on an A40). + scratch = SolpropJulia.scratch(c, heavy ? :heavy : :reduce, typeof(neutral), nt * nm) + each!(c, nt, nm) do t, m + @inbounds scratch[t+(m-1)*nt] = @inline f(t, m) + end + # The reduction's own scratch, kept (AK's `workspace`): a new partials buffer a call + # was an allocation from the pool and its copies, dozens a step. + workspace = get!(c.scratch, (:reduce_workspace, typeof(op), typeof(neutral), nt * nm)) do + AK.workspace(AK.mapreduce, identity, op, scratch; backend=c.backend, init=neutral, + neutral=neutral) + end + AK.mapreduce(identity, op, scratch; backend=c.backend, init=neutral, neutral=neutral, + workspace=workspace) +end + +"""The sum of `f(t, m)` over every sample into `out[1]`, which the next kernel reads: on a +GPU it stays on the device (each value the host waits for cost about 0.2 ms on an M5 +Max), on a CPU it is `reduce_each`'s, the same bits.""" +function sum_device!(f::F, out, c, nt::Integer, nm::Integer; heavy=false) where {F} + nt, nm = Int(nt), Int(nm) + if oncpu(c) + @inbounds out[1] = reduce_each(f, +, zero(eltype(out)), c, nt, nm; heavy=heavy) + return out + end + terms = SolpropJulia.scratch(c, :sum_terms, eltype(out), 1, nt * nm) + each!(c, nt, nm) do t, m + @inbounds terms[1, t+(m-1)*nt] = @inline f(t, m) + end + tally!(:launch) + sum!(reshape(out, 1, 1), terms) + out +end + +# FFTW's planner measures every plan unless SOLPROP_FFTW_PLAN says otherwise. Unlike +# native's policy (rows estimated when threaded), a threaded estimate is far slower +# here: the Raman convolution's c2r of 73728 x 17 takes 6.6 ms estimated and 1.49 ms +# measured on four Xeon cores, 7.5 and 4.9 ms on one (planning is at construction). +const FLAGS = Dict("estimate" => FFTW.ESTIMATE, "measure" => FFTW.MEASURE, + "patient" => FFTW.PATIENT) +function plan_flags() + chosen = get(ENV, "SOLPROP_FFTW_PLAN", "") + isempty(chosen) && return FFTW.MEASURE + haskey(FLAGS, chosen) || throw(ArgumentError("SOLPROP_FFTW_PLAN must be estimate, measure or patient")) + FLAGS[chosen] +end + +"""Plan `kind(a, args...)` for the engine's device; inverses are left unnormalised. + +On a CPU with several tasks the transform is split into blocks of whole batches along +dimension `batch` (columns for row transforms, rows for transverse planes), one +single-threaded plan each, run by the pool that runs every other pass: FFTW's and +BLAS's own threads beside Polyester's spinning ones made a four-thread rdw run seven +times slower than one thread. Measuring overwrites `a`: plan before storing in it. +""" +function plan(c, kind, a, args...; threads=c.fft_threads, batch=2) + oncpu(c) || return device_plan(c, kind, a, args...) + blocks = min(threads, size(a, batch)) + blocks <= 1 && return kind(a, args...; flags=plan_flags(), num_threads=1) + ranges = [r for r in Iterators.partition(axes(a, batch), cld(size(a, batch), blocks))] + # A block's view starts anywhere in the array: its plan may not assume alignment. + plans = [kind(block_view(a, batch, r), args...; flags=plan_flags() | FFTW.UNALIGNED, + num_threads=1) for r in ranges] + Blocked(plans, ranges, batch) +end + +struct Blocked{P} + plans::Vector{P} + ranges::Vector{UnitRange{Int}} + batch::Int +end +block_view(a, batch, r) = batch == 2 ? view(a, :, r) : view(a, r, ntuple(_ -> Colon(), ndims(a) - 1)...) +function LinearAlgebra.mul!(y, p::Blocked, x) + @batch for b in eachindex(p.plans) + mul!(block_view(y, p.batch, p.ranges[b]), p.plans[b], block_view(x, p.batch, p.ranges[b])) + end + y +end +"""`mul!(outs[k], p, ins[k])` for each pair: on a CPU one pool task for each block of +each, so that transforms over a few columns (a capillary's modes) fill the pool.""" +function transform_all!(p::Blocked, outs::Tuple, ins::Tuple) + blocks = length(p.plans) + @batch for k in 1:blocks*length(outs) + j, b = divrem(k - 1, blocks) .+ 1 + transform_block!(p, outs, ins, j, b) + end +end +@inline function transform_block!(p, outs, ins, j, b) + # A tuple's elements by a run-time index: each pair's arrays share one type here. + r = p.ranges[b] + mul!(block_view(outs[j], p.batch, r), p.plans[b], block_view(ins[j], p.batch, r)) +end +# On a GPU each transform over a capillary's few modes is a few blocks (one a column, +# four for rdw, 96 us each on an A40): the group goes through one batched plan over a +# staging buffer instead, the copies a few microseconds each. The staging lives in the +# engine's workspace (`stage`, a `Ref`), not in a global table of plans. +function transform_all!(p, outs::Tuple, ins::Tuple, stage::Ref, c) + x = first(ins) + if x isa Array + foreach((y, x) -> mul!(y, p, x), outs, ins) + return nothing + end + n, columns = length(ins), size(x, 2) + held = stage[] + if held === nothing || size(held[1], 2) != n * columns + staged = similar(x, size(x, 1), n * columns) + result = similar(first(outs), size(first(outs), 1), n * columns) + held = (staged, result, eltype(x) <: Real ? plan(c, plan_rfft, staged, 1) : plan(c, plan_fft, staged, 1)) + stage[] = held + end + staged, result, batched = held + for j in 1:n + device_copy!(view(staged, :, (j-1)*columns+1:j*columns), ins[j], c) + end + mul!(result, batched, staged) + for j in 1:n + device_copy!(outs[j], view(result, :, (j-1)*columns+1:j*columns), c) + end + nothing +end +transform_all!(p::Blocked, outs::Tuple, ins::Tuple, ::Ref, c) = transform_all!(p, outs, ins) + +function Base.:*(p::Blocked, x) + @batch for b in eachindex(p.plans) + p.plans[b] * block_view(x, p.batch, p.ranges[b]) + end + x +end + +"""`copyto!(target, source)` for two state-sized arrays of the device: on a CPU as the +pool's tasks, since one thread's copy of a Cartesian state (226 MB) took 45 ms.""" +function pool_copy!(target, source, c) + each!(c, size(target)...) do f, m + @inbounds target[f, m] = source[f, m] + end + target +end + +"""`copyto!(target, source)` for two matrices of the device, views included, as one +kernel: Metal.jl's `copyto!` into or out of a view took about 200 us (a staged FFT batch +of three 8192 x 4 transforms 1.6 ms against 0.11 ms for three separate ones).""" +device_copy!(target, source, c) = pool_copy!(target, source, c) + +"""`C = alpha A B + beta C`: on a CPU, blocks of rows of `C` and `A` as the pool's tasks. + +A complex `C` and `A` against a real `B` are their real views, of twice the rows: one +real GEMM, BLAS's or cuBLAS's. Julia's own mixed-type product is generic, slow on a GPU, +and in binary32 not safe to run from several tasks (a 1.5 relative error on the Xeon, +LinearAlgebra in Julia 1.13.3). +""" +function gemm!(C, A, B, alpha, beta, c) + # A scale (a taper's) at the arrays' precision: an Apple GPU takes no binary64. + alpha isa Bool || (alpha = real(eltype(C))(alpha)) + if eltype(C) <: Complex && eltype(A) <: Complex && eltype(B) <: Real + return gemm!(real_rows(C), real_rows(A), B, alpha, beta, c) + end + if !oncpu(c) + tally!(:gemm) + A, B = dense(c, A, :gemm_a), dense(c, B, :gemm_b) + end + if oncpu(c) && eltype(C) <: Real && (size(B, 2) <= THIN || size(B, 1) <= THIN) + return thin_gemm!(C, A, B, alpha, beta, c) + end + blocks = oncpu(c) ? min(c.tasks, cld(length(C), PARALLEL_SAMPLES ÷ 4)) : 1 + blocks <= 1 && return mul!(C, A, B, alpha, beta) + rows = cld(size(C, 1), blocks) + @batch for b in 1:blocks + r = (b-1)*rows+1:min(b * rows, size(C, 1)) + mul!(view(C, r, :), view(A, r, :), B, alpha, beta) + end + C +end + +"""The running sums down each column of `v` (`AK.accumulate!`, `dims=1`), with the +scan's scratch kept on a GPU: a new one a call was a pool allocation, and inside a +captured source graph (`source!`) a freed buffer the replay would still read.""" +function scan_columns!(v, c, init) + oncpu(c) && return AK.accumulate!(+, v; dims=1, init=init, backend=c.backend) + workspace = get!(c.scratch, (:scan_workspace, eltype(v), size(v))) do + AK.workspace(AK.accumulate!, +, v; dims=1, init=init, backend=c.backend) + end + AK.accumulate!(+, v; dims=1, init=init, backend=c.backend, workspace=workspace) +end + +"""On a GPU, an operand that is a strided view (a range of a matrix's rows) copied into +scratch: Metal.jl's product of one takes a generic kernel, about 240 us for 16384 x 36 +x 8 on the M5 Max against 65 to 140 us copied first.""" +function dense(c, X::SubArray{<:Any,2}, use) + strides(X) == (1, size(X, 1)) && return X + tally!(:dense_copy) + device_copy!(scratch(c, use, eltype(X), size(X)...), X, c) +end +dense(c, X, use) = X + +"""The nodes (or columns) a source evaluates at once: the translation's chunk, sized for a +CPU's memory budget, on a CPU; on a GPU all of them, up to 2^26 samples a buffer, since +each chunk repeats the synthesis, the responses and the projections as launches +(`ctc_reduced`'s 33 nodes were three chunks of 11).""" +node_chunk(c, chunk, count, nt) = + oncpu(c) ? min(chunk, count) : min(count, max(chunk, (1 << 26) ÷ max(nt, 1))) + +"""Rows `first:last` of a constant table (a projection), for a product: a view on a CPU; +on a GPU a contiguous copy, made once and kept in `c.scratch`, since a product with a +strided operand there takes a generic kernel or a copy every call (`dense`).""" +function table_rows(c, table, first, last) + oncpu(c) && return @view(table[first:last, :]) + first == 1 && last == size(table, 1) && return table + get!(() -> (tally!(:scratch_alloc); copy(@view(table[first:last, :]))), + c.scratch, (:table_rows, objectid(table), first, last)) +end + +"""A product's thin side, at most this many columns or inner terms: a loop, not BLAS.""" +const THIN = 8 + +"""`C = alpha A B + beta C` for real matrices with a thin `B`: as the pool's tasks over +blocks of rows, each a column of `C` at a time, a contiguous axpy per inner term. +A capillary's one mode made each projection sixteen BLAS calls of a vector each, +whose overheads were most of argon's 0.25 ms a source.""" +function thin_gemm!(C, A, B, alpha, beta, c) + rows, inner = size(A) + columns = size(B, 2) + blocks = max(1, min(c.tasks, cld(rows * (inner + columns), PARALLEL_SAMPLES ÷ 4))) + span = cld(rows, blocks) + a, b = eltype(C)(alpha), eltype(C)(beta) + @batch for block in 1:blocks + r = (block-1)*span+1:min(block * span, rows) + @inbounds for j in 1:columns + if iszero(b) + @simd for t in r + C[t, j] = 0 + end + elseif !isone(b) + @simd for t in r + C[t, j] *= b + end + end + for p in 1:inner + weight = a * B[p, j] + @simd for t in r + C[t, j] += A[t, p] * weight + end + end + end + end + C +end + +"""A column-contiguous complex matrix as the real one of its interleaved parts.""" +real_rows(X) = reshape(reinterpret(real(eltype(X)), X), 2size(X, 1), size(X, 2)) + +# Section timers for development: SOLPROP_JULIA_TIMING=1 when the module loads. Off, +# `@section` costs one branch. +const TIMING = Ref(false) +const TIMES = Dict{Symbol,Float64}() +# A device's timed sections wait for its queue at both ends (`synchronize_all`). +const SYNCHRONIZE = Ref{Any}(() -> nothing) +# SOLPROP_JULIA_TIMING=host: the sections unsynchronised, so each measures the host's +# own time in it (enqueueing, host arithmetic, and any wait it makes itself). +const HOST_TIMING = Ref(false) +macro section(name, ex) + quote + if TIMING[] + HOST_TIMING[] || SYNCHRONIZE[]() + local started = time_ns() + local result = $(esc(ex)) + HOST_TIMING[] || SYNCHRONIZE[]() + TIMES[$name] = get(TIMES, $name, 0.0) + (time_ns() - started) * 1e-9 + result + else + $(esc(ex)) + end + end +end +timings() = Dict(String(k) => v for (k, v) in TIMES) +clear_timings() = (empty!(TIMES); nothing) +timing_enabled() = TIMING[] + +# --- Device graphs ------------------------------------------------------------------- + +"""`SOLPROP_JULIA_GRAPH=0` launches every source's passes one by one.""" +const GRAPHS = Ref(true) +"""Whether the device's extension captures and replays graphs (CUDA's does).""" +graph_capable(backend) = false +"""Capture `f`'s device work on the task's stream into an executable graph, or return +`nothing` where the device cannot.""" +graph_capture(backend, f) = nothing +graph_launch(exec) = throw(ArgumentError("no device graphs on this backend")) + +# --- Stage scalars in device memory --------------------------------------------------- + +"""A source's stage scalars on a device that replays graphs: the Kerr factor, then each +plasma channel's density and preionisation, in one device vector the kernels read +(`stage_value`), so that one captured graph serves every stage of a gradient. Slot 1 is +the factor; channel `k`'s density and preionisation are slots `2k` and `2k + 1`.""" +function stage_slots(c, slots) + get!(c.scratch, :stage_slots) do + # (The staging is pageable on purpose: the driver copies it at once, so the + # next stage may rewrite it; a pinned copy would only be queued.) + (host=fill(NaN, slots), device=KA.allocate(c.backend, c.T, slots), staging=zeros(c.T, slots)) + end +end +"""A kernel's view of stage scalar `index` (times `scale`): the device vector's slot +where sources replay graphs, else the host's value.""" +function stage_scalar(c, index, host_value, scale=one(c.T)) + T = c.T + graph_values(c) || return T(host_value) * T(scale) + (values=c.scratch[:stage_slots].device, index=index, scale=T(scale)) +end +@inline stage_value(x::Number) = x +@inline stage_value(s::NamedTuple{(:values, :index, :scale)}) = @inbounds s.values[s.index] * s.scale + +# --- Long binary64 transforms on a GPU, four-step ------------------------------------- + +"""Whether the device's library takes long binary64 transforms slowly enough to split +them (`LongFFT`): an extension's hook, false unless it says otherwise.""" +long_transforms(backend) = get(ENV, "SOLPROP_JULIA_FOURSTEP", "") == "1" + +"""Plan `kind(a, args...)` on a GPU: the library's plan, or a four-step one (`LongFFT`) +for a long binary64 transform along the first dimension where the device asks for it.""" +function device_plan(c, kind, a, args...) + split = long_transforms(c.backend) && get(ENV, "SOLPROP_JULIA_FOURSTEP", "1") != "0" + split || return kind(a, args...) + real_input = kind === plan_rfft + output_real = kind === plan_brfft + n = output_real ? Int(args[1]) : size(a, 1) + region = last(args) + shape = factor_length(n) + (ndims(a) == 2 && region == 1 && real(eltype(a)) === Float64 && shape !== nothing && + (!real_input && !output_real ? true : iseven(n))) || return kind(a, args...) + sign = kind in (plan_fft, plan_fft!, plan_rfft) ? -1 : 1 + LongFFT(c, a, n, shape..., sign, kind in (plan_fft!, plan_bfft!), real_input, output_real) +end + +"""`n = n1 n2` with `n2` the smallest divisor that keeps `n1 <= 512`, for `n >= 2048`; +`nothing` otherwise (short transforms, or a large prime factor).""" +function factor_length(n) + n < 2048 && return nothing + for n2 in cld(n, 512):64 + n % n2 == 0 && return (n ÷ n2, n2) + end + nothing +end + +"""A length-`n` transform along the first dimension as `n = n1 n2`: with `n = a + n1 j` +and `k = n2 p + q`, `X[n2 p + q] = sum_a w_n1^(a p) w_n^(a q) sum_j x[a + n1 j] w_n2^(j q)`. +The samples go to an `(n1, m, n2)` work array, the short transforms run along its last +dimension (one plan, strided), the twiddles, the long transforms along its first +(contiguous), and the result comes back in order. On an A40, cuFFT's own binary64 +transform of 5120 or 10240 points is one block a transform, 96 or 138 us at any batch; +the split takes about 23 (DMOG, `scripts/fft_fourstep2.jl`). Real input is promoted to +complex, and a real output's Hermitian spectrum is completed first: both twice the +arithmetic of a real transform, still a quarter of the time.""" +struct LongFFT{S,L,W,T,C} + short::S + long::L + work::W + twiddle::T + device::C + n::Int + n1::Int + n2::Int + columns::Int + inplace::Bool + real_input::Bool + output_real::Bool + sign::Int + # The same transform over other column counts, planned when first asked. + others::Dict{Int,Any} +end +function LongFFT(c, a, n, n1, n2, sign, inplace, real_input, output_real) + twiddle = upload(c, [cispi(2 * sign * (p - 1) * (j - 1) / n) for p in 1:n1, j in 1:n2]) + # What `each!` reads of the engine's configuration. + device = (backend=c.backend, tasks=c.tasks) + long_columns(a, size(a, 2), twiddle, device, n, n1, n2, sign, inplace, real_input, output_real) +end +function long_columns(a, m, twiddle, device, n, n1, n2, sign, inplace, real_input, output_real) + work = similar(a, ComplexF64, n1, m, n2) + short = sign < 0 ? plan_fft!(work, 3) : plan_bfft!(work, 3) + long = sign < 0 ? plan_fft!(work, 1) : plan_bfft!(work, 1) + LongFFT(short, long, work, twiddle, device, n, n1, n2, m, inplace, real_input, output_real, + sign, Dict{Int,Any}()) +end + +function long_transform!(y, p::LongFFT, x) + m = size(x, 2) + if m != p.columns + q = get!(p.others, m) do + long_columns(p.work, m, p.twiddle, p.device, p.n, p.n1, p.n2, p.sign, p.inplace, + p.real_input, p.output_real) + end + return long_transform!(y, q, x) + end + long_transform!(y, p, x, Val(p.real_input), Val(p.output_real)) +end +function long_transform!(y, p::LongFFT, x, ::Val{R}, ::Val{O}) where {R,O} + (; work, twiddle, n, n1, n2, columns) = p + c = p.device + half = n ÷ 2 + tally!(:long_fft) + # The samples in, `x[a + n1 j]` to `work[a, b, j]`; a half spectrum completed. + each!(c, n, columns) do t, b + @inbounds begin + i = t - 1 + value = O ? (i <= half ? complex(x[t, b]) : conj(complex(x[n-i+1, b]))) : + complex(x[t, b]) + work[i % n1 + 1, b, i ÷ n1 + 1] = value + end + end + p.short * work + flat = reshape(work, n1, columns * n2) + each!(c, n1, columns * n2) do a, r + @inbounds flat[a, r] *= twiddle[a, (r - 1) ÷ columns + 1] + end + p.long * work + # `work[p, b, q]` is `X[n2 p + q]`. + rows = R ? half + 1 : n + each!(c, rows, columns) do t, b + @inbounds begin + k = t - 1 + value = work[k ÷ n2 + 1, b, k % n2 + 1] + y[t, b] = O ? real(value) : value + end + end + y +end + +LinearAlgebra.mul!(y, p::LongFFT, x) = long_transform!(y, p, x) +Base.:*(p::LongFFT, x) = p.inplace ? long_transform!(x, p, x) : + throw(ArgumentError("an out-of-place LongFFT takes mul!")) diff --git a/julia/src/march.jl b/julia/src/march.jl new file mode 100644 index 000000000..ba2c72741 --- /dev/null +++ b/julia/src/march.jl @@ -0,0 +1,451 @@ +# The exponential Adams march, executed by the engine (native's SEP 39 phase 2 march). +# +# solprop's `AdamsMarch` and its controller core (`solprop.backends.adams_core`) are +# the reference, and native's `adams_march.cpp` the transcription this follows: the +# march runs a run of attempts on the resident engine and returns to Python only at a +# host event (the target reached, an accepted step with the driver's work, a monitor +# check, the call's bound, the budget, the floor or an error). Each decision performs +# its Python function's operations in order, with Python's comparisons: `min(a, b)` is +# `b` only if `b < a`, `max` keeps the first unless a later is strictly greater, a +# comparison with NaN is false. Julia contracts nothing unasked, and `pow` is the C +# library's, as Python's float power is. + +const LIBM = Sys.isapple() ? "libSystem.B.dylib" : "libm.so.6" +"""Python's `x ** y` for floats: the C library's `pow`.""" +cpow(x::Float64, y::Float64) = ccall((:pow, LIBM), Float64, (Float64, Float64), x, y) +py_min(a, b) = b < a ? b : a +py_max(a, b) = b > a ? b : a +"""`math.ulp` at a magnitude: the spacing above `|x|`; NaN for a non-finite one.""" +function ulp(x::Float64) + m = abs(x) + isfinite(m) ? nextfloat(m) - m : NaN +end +"""`bisect.bisect_left` and `bisect_right`: how many entries lie below (at or below).""" +bisect_left(values, x) = searchsortedfirst(values, x) - 1 +bisect_right(values, x) = searchsortedlast(values, x) + +"""Every number the algorithm reads: solprop's `MarchPolicy`, field for field.""" +struct Policy + order::Int + variable_order::Bool + safety::Float64 + max_growth::Float64 + min_factor::Float64 + rejection_growth::Float64 + hysteresis::Float64 + restart_after::Int + collar_stability::Float64 + real_intervals::Vector{Float64} + collar_rate::Float64 + has_budget::Bool + max_calls::Int + equal_approach::Bool + dz_min::Float64 + dz_max::Float64 + stretch::Float64 + z_end::Float64 + save_planes::Vector{Float64} + hard_kinks::Vector{Float64} + breakpoints::Vector{Float64} + landing_ulps::Int + has_quiet_interval::Bool + quiet_interval::Float64 +end + +"""A march's configuration: its policy, the stage count the stage scalars fill, and +the operator's rate table for a compensated trial (`translate.linop.rate_weights`).""" +struct MarchConfig{R} + policy::Policy + stages::Int + varying::Bool + compensated::Bool + split::Bool + rate::R +end + +const NONE, MAX_STEP, INTERVAL_WIDTH, HARD_KINK, SAVE_PLANE, END = 0, 1, 2, 3, 4, 5 +const REACHED, HOST_STEP, MONITOR, BOUND, BUDGET, FLOOR, ERROR, DIVERGED = 0:7 +const STAGE_NONE, STARTUP, TRIAL, ACCEPT = 0:3 +const CONVERGENCE, BACKEND, VALUE = 1:3 + +# --- the decisions (adams_core) -------------------------------------------------------- + +function factor(p::Policy, norm, order, growth) + norm <= 0.0 && return growth + raw = p.safety * cpow(norm, -1.0 / Float64(order + 1)) + py_min(growth, py_max(p.min_factor, raw)) +end + +"""A trial's history newest first: its nodes and rows, its order and scored orders.""" +function stencil(p::Policy, z, dz, history_z, history_row, stored_order, last_rejected) + held = length(history_z) + nodes = [(history_z[held-i] - z) / dz for i in 0:held-1] + rows = [history_row[held-i] for i in 0:held-1] + order = min(stored_order, held) + rising = !last_rejected && held > order + orders = [order] + if p.variable_order + order >= 2 && order - 1 <= p.order && order - 1 <= held && push!(orders, order - 1) + order + 1 <= p.order && order + 1 <= held && rising && push!(orders, order + 1) + end + (nodes=nodes, rows=rows, held=held, order=order, orders=orders) +end + +function stable_factor(p::Policy, order, dz, quiet) + (p.collar_rate <= 0.0 || quiet) && return Inf + p.collar_stability * p.real_intervals[order] / (p.collar_rate * dz) +end + +function order_weight(p::Policy, norm, order, dz, quiet) + rate = norm <= 0.0 ? Inf : cpow(norm, -1.0 / Float64(order + 1)) + py_min(p.safety * rate, stable_factor(p, order, dz, quiet)) +end + +"""The order to store, and the order and norm that set the next step.""" +function choose_order(p::Policy, s, norms, dz, quiet) + current = s.order + p.variable_order || return (p.order, current, norms[1]) + weights = [order_weight(p, norms[i], s.orders[i], dz, quiet) for i in eachindex(s.orders)] + best = 1 + for i in 2:length(weights) + weights[i] > weights[best] && (best = i) + end + if s.orders[best] != current && weights[best] > p.hysteresis * weights[1] + return (s.orders[best], s.orders[best], norms[best]) + end + (current, current, norms[1]) +end + +function rejection(p::Policy, norm, order, rejections, held) + count = rejections + 1 + restart = count >= p.restart_after && held > 1 + scale = !isfinite(norm) ? p.min_factor : factor(p, norm, order, p.rejection_growth) + (scale, restart ? 0 : count, restart) +end + +quiet_capped(p::Policy, proposal, quiet) = + (!quiet || !p.has_quiet_interval) ? proposal : py_min(proposal, p.quiet_interval) + +function collar_reentry(p::Policy, proposal, order, was_quiet, quiet) + (!(was_quiet && !quiet) || p.collar_rate <= 0.0) && return proposal + py_min(proposal, p.collar_stability * p.real_intervals[order] / p.collar_rate) +end + +"""`stepper.schedule.landing`: the step a landing allows, its target and end.""" +function landing(p::Policy, z, dz, z_end) + (dz > 0.0 && isfinite(dz)) || throw(ArgumentError("dz must be finite and positive, got $dz")) + edges = p.breakpoints + edges[1] <= z <= edges[end] || throw(ArgumentError("z = $z m lies outside the operator table")) + tolerance = p.landing_ulps * ulp(py_max(abs(z), abs(z_end))) + z >= z_end - tolerance && throw(ArgumentError("z = $z m is already at or past z_end")) + found = bisect_right(edges, z) + index = min(found == 0 ? 0 : found - 1, length(edges) - 2) + width = edges[index+2] - edges[index+1] + # The caps, then the landings: the shortest wins, among equals the higher target. + better(c, h) = c[1] < h[1] ? true : h[1] < c[1] ? false : c[2] > h[2] + cap = (dz, NONE, 0.0) + for other in ((p.dz_max, MAX_STEP, 0.0), (width, INTERVAL_WIDTH, 0.0)) + better(other, cap) && (cap = other) + end + land, any = (0.0, NONE, 0.0), false + consider(target, position) = (candidate = (position - z, target, position); + if !any || better(candidate, land); land = candidate; any = true; end) + from = z + tolerance + k = bisect_left(p.hard_kinks, from) + k < length(p.hard_kinks) && consider(HARD_KINK, p.hard_kinks[k+1]) + q = bisect_left(p.save_planes, from) + q < length(p.save_planes) && consider(SAVE_PLANE, p.save_planes[q+1]) + !(z_end < from) && consider(END, z_end) + land[1] <= cap[1] && return (dz=land[1], target=land[2], landed=true, at=land[3]) + land[1] <= py_min(p.stretch * cap[1], p.dz_max) && + return (dz=land[1], target=land[2], landed=true, at=land[3]) + (dz=cap[1], target=cap[2], landed=false, at=0.0) +end + +"""The next forced landing strictly beyond `z` (`adams_core.next_landing`), or nothing.""" +function next_landing(p::Policy, z, target) + tolerance = p.landing_ulps * ulp(py_max(abs(z), abs(target))) + nearest = target + for positions in (p.save_planes, p.hard_kinks) + index = bisect_right(positions, z + tolerance) + index < length(positions) && (nearest = py_min(nearest, positions[index+1])) + end + nearest > z + tolerance ? nearest : nothing +end + +"""The step to take, where it ends and whether that is a hard kink.""" +function approach(p::Policy, z, stop, target) + if !stop.landed && p.equal_approach + ahead = next_landing(p, z, target) + if ahead !== nothing && stop.dz < ahead - z && ahead - z < 2.0 * stop.dz + half = 0.5 * (ahead - z) + return (dz=half, finish=z + half, kink=false) + end + end + finish = stop.landed ? stop.at : z + stop.dz + tolerance = p.landing_ulps * ulp(py_max(abs(finish), 1.0)) + interior = finish < p.z_end - tolerance + on_kink = interior && any(kink -> abs(kink - finish) <= tolerance, p.hard_kinks) + (dz=stop.dz, finish=finish, kink=stop.target == HARD_KINK || on_kink) +end + +proposal(p::Policy, dz, f) = py_min(dz * f, p.dz_max) +"""`TransverseEdge.due`: read here when the next proposal would carry past the read.""" +read_due(has_read_at, read_at, z, ahead) = + has_read_at && z + ahead >= read_at - 1e-12 * py_max(abs(z), 1.0) +reached(position, target, ulps) = + position >= target - ulps * ulp(py_max(abs(position), abs(target))) + +# --- the engine's part ----------------------------------------------------------------- + +"""`translate.linop.rate_weights`: the operator's rate terms at `z`, read on the side +of a breakpoint `before` asks, by the transcribed Clenshaw pass on that interval.""" +function rate_at(table, z, before) + edges = table.edges + low, high = edges[1], edges[end] + slack = 1e-10 * (high - low) + (z < low - slack || z > high + slack) && + throw(ArgumentError("z = $z is outside the represented span [$low, $high]")) + index = min(max(searchsortedlast(edges, z) - 1, 0), length(edges) - 2) + before && index > 0 && z <= edges[index+1] && (index -= 1) + out = zeros(1, size(table.c, 3)) + clenshaw_points!([Float64(z)], [edges[index+1], edges[index+2]], -Inf, Inf, + view(table.c, index+1:index+1, :, :), out) + vec(out) +end + +"""The stage scalars of a trial from `z` over `dz` (the adapter's `_prepare_stages`).""" +stage_positions(m::MarchConfig, z, dz) = [fill(Float64(z), m.stages - 1); z + dz] + +function march_start!(engine, m::MarchConfig, z) + m.varying && configure_stages_at!(engine, z, stage_positions(m, z, 0.0)) + m.compensated && configure_adams_rate!(engine, rate_at(m.rate, z, false)) + adams_start!(engine) +end + +function march_trial!(engine, m::MarchConfig, z, dz, s) + m.varying && @section :march_stages configure_stages_at!(engine, z, stage_positions(m, z, dz)) + rate = m.compensated ? rate_at(m.rate, z + dz, true) : Float64[] + @section :march_tables configure_adams_nodes!(engine, s.nodes, s.order, s.orders, s.rows, rate) + @section :adams_trial adams_trial!(engine, dz) +end + +"""Adopt the held trial into row `free`, commit it; return its quadrature alarm. With +a split collar the commit also forms the power the split finds (`split_power`).""" +function march_accept!(engine, dz, free, split) + @section :adams_accept adams_accept!(engine, free) + @section :commit commit!(engine, Float64(dz), split) +end + +# --- the run --------------------------------------------------------------------------- + +"""Hold a run's march configuration: the policy's numbers as `MarchPolicy` gives them.""" +function configure_march!(engine, numbers, real_intervals, save_planes, hard_kinks, + breakpoints, stages, varying, compensated, split, rate_edges, rate_c) + f = Vector{Float64}(numbers) + policy = Policy(Int(f[1]), f[2] != 0, f[3], f[4], f[5], f[6], f[7], Int(f[8]), f[9], + Vector{Float64}(real_intervals), f[10], f[11] != 0, Int(f[12]), + f[13] != 0, f[14], f[15], f[16], f[17], Vector{Float64}(save_planes), + Vector{Float64}(hard_kinks), Vector{Float64}(breakpoints), Int(f[18]), + f[19] != 0, f[20]) + rate = compensated ? (edges=Vector{Float64}(rate_edges), c=Array{Float64,3}(rate_c)) : + nothing + engine.work.march[] = MarchConfig(policy, Int(stages), Bool(varying), Bool(compensated), + Bool(split), rate) + nothing +end + +"""One call of the march: from the state Python holds to a host event (SEP 39 4.8). + +`zs` = (z, proposal); `counts` = (order, rejections, last_rejected, collar_was_quiet); +the history oldest first; `ledger` (startup, predictor, rejected, accepted_steps, +rejected_steps, restarts, failure_restarts), `CallLedger`'s counters; `limits` = (target, check_interval, +last_check, read_at, read_spacing, step_cap, max_seconds) and `flags` = (quiet, +host_step, monitor, first_check, has_read_at, max_attempts). Returns the state, the +attempts' rows (end, dz, norm, accepted, order, wall), the accepted orders, the reason +and its details, the last accepted step's quadrature alarm, and the first above 1e-6 +with where it was. +""" +march_run!(engine, zs, counts, history_z, history_predicted, history_row, ledger, limits, + flags) = + run_march(engine, engine.work.march[], Vector{Float64}(zs), Vector{Int}(counts), + Vector{Float64}(history_z), Vector{Bool}(history_predicted), + Vector{Int}(history_row), Vector{Int}(ledger), Vector{Float64}(limits), + Vector{Int}(flags)) + +function run_march(engine, m::MarchConfig, zs, counts, hz, hp, hr, ledger, limits, flags) + p = m.policy + started = time() + z, proposed = zs + order, rejections = counts[1], counts[2] + last_rejected, was_quiet = counts[3] != 0, counts[4] != 0 + target, check_interval, last_check, read_at, read_spacing, step_cap, max_seconds = limits + quiet, monitor, first_check, has_read_at = flags[1] != 0, flags[3] != 0, flags[4] != 0, + flags[5] != 0 + host_step, max_attempts = flags[2], flags[6] + rows, orders = Float64[], Int[] + reason, cost, floor_proposal, stage, category, message = REACHED, 0, 0.0, STAGE_NONE, 0, "" + alarm, alarm_z, first_alarm = NaN, NaN, NaN + # Each accepted step's split power and length, for the adapter's split sums. + split_powers, split_steps = Vector{Float64}[], Float64[] + accepted = 0 + elapsed() = time() - started + record(finish, dz, norm, kept, o) = + append!(rows, (finish, dz, isfinite(norm) ? norm : Inf, kept ? 1.0 : 0.0, Float64(o), + elapsed())) + total() = ledger[1] + ledger[2] + function fail(at, error) + reason, stage = ERROR, at + message = sprint(showerror, error) + category = error isa ArgumentError ? VALUE : BACKEND + end + while !reached(z, target, p.landing_ulps) + # The budget, before any call is made (`_afford`). + need = (isempty(hz) ? 1 : 0) + 1 + if p.has_budget && total() + need > p.max_calls + reason, cost = BUDGET, need + @goto done + end + if isempty(hz) + ledger[1] += 1 + failed = false + try + march_start!(engine, m, z) + catch error + fail(STARTUP, error) + failed = true + end + failed && @goto done + hz, hp, hr = [z], [false], [0] + order = p.variable_order ? 1 : p.order + end + # The caps: the quiet collar's, the transverse edge's, the split's, re-entry's. + capped = quiet_capped(p, proposed, quiet) + capped = has_read_at ? py_min(capped, read_spacing) : capped + capped = py_min(capped, step_cap) + capped = collar_reentry(p, capped, order, was_quiet, quiet) + was_quiet = quiet + step = nothing + try + step = approach(p, z, landing(p, z, capped, target), target) + catch error + fail(TRIAL, error) + end + step === nothing && @goto done + s = stencil(p, z, step.dz, hz, hr, order, last_rejected) + ledger[2] += 1 + norms = nothing + try + norms = march_trial!(engine, m, z, step.dz, s) + catch error + fail(TRIAL, error) + end + norms === nothing && @goto done + norm = norms[1] + if !(norm <= 1.0) + # A rejection keeps the accepted history; `restart_after` in a row restart it. + ledger[3] += 1 + ledger[5] += 1 + last_rejected = true + scale, rejections, restart = rejection(p, norm, s.order, rejections, length(hz)) + if restart + hz, hp, hr = Float64[], Bool[], Int[] + ledger[7] += 1 + end + next = proposal(p, step.dz, scale) + if next < p.dz_min + reason, floor_proposal = FLOOR, next + @goto done + end + proposed = next + record(step.finish, step.dz, norm, false, s.order) + else + # The new sample takes the lowest row the kept entries do not use. + keep = min(p.order, length(hz)) + kz, kp, kr = hz[end-keep+1:end], hp[end-keep+1:end], hr[end-keep+1:end] + free = 0 + while free in kr + free += 1 + end + failed = false + try + alarm = march_accept!(engine, step.dz, free, m.split) + if m.split + push!(split_powers, split_power(engine)) + push!(split_steps, step.dz) + end + catch error + fail(ACCEPT, error) + failed = true + end + failed && @goto done + # The first step past the alarm's level, for the adapter's one warning. + if alarm > 1e-6 && isnan(alarm_z) + alarm_z = z + step.dz + first_alarm = alarm + end + hz, hp, hr = [kz; z + step.dz], [kp; true], [kr; free] + ledger[4] += 1 + rejections = 0 + push!(orders, s.order) + stored, control, control_norm = choose_order(p, s, norms, step.dz, quiet) + order = stored + last_rejected = false + z = step.finish + if step.kink + hz, hp, hr = Float64[], Bool[], Int[] + ledger[6] += 1 + end + next = proposal(p, step.dz, factor(p, control_norm, control, p.max_growth)) + record(step.finish, step.dz, norm, true, s.order) + if next < p.dz_min + reason, floor_proposal = FLOOR, next + @goto done + end + proposed = next + accepted += 1 + if reached(z, target, p.landing_ulps) + reason = REACHED + @goto done + end + if (host_step > 0 && accepted == host_step) || + read_due(has_read_at, read_at, z, proposed) + reason = HOST_STEP + @goto done + end + if monitor && (first_check || z - last_check >= check_interval) + reason = MONITOR + @goto done + end + end + if length(rows) ÷ 6 >= max_attempts || elapsed() >= max_seconds + reason = BOUND + @goto done + end + end + reason = REACHED + @label done + (zs=[z, proposed], counts=[order, rejections, Int(last_rejected), Int(was_quiet)], + history_z=hz, history_predicted=hp, history_row=hr, ledger=ledger, rows=rows, + orders=orders, reason=reason, cost=cost, floor_proposal=floor_proposal, stage=stage, + category=category, message=message, alarm=alarm, alarm_z=alarm_z, + first_alarm=first_alarm, + # Flat (a step's power after another): a vector's buffer path is compiled already. + split_powers=isempty(split_powers) ? Float64[] : reduce(vcat, split_powers), + split_steps=split_steps) +end + +# The decisions a warm-up's one accepted attempt does not reach compile into the +# package image, not inside a run's first window (a rejection there took 9 ms). +for T in (Int,) + precompile(rejection, (Policy, Float64, T, T, T)) + precompile(read_due, (Bool, Float64, Float64, Float64)) + precompile(choose_order, (Policy, NamedTuple{(:nodes, :rows, :held, :order, :orders), + Tuple{Vector{Float64}, Vector{T}, T, T, Vector{T}}}, + Vector{Float64}, Float64, Bool)) + precompile(next_landing, (Policy, Float64, Float64)) + precompile(collar_reentry, (Policy, Float64, T, Bool, Bool)) +end + +const configure_march_b = configure_march! +march_run_b(args...) = flushed(march_run!, args...) diff --git a/julia/src/modal.jl b/julia/src/modal.jl new file mode 100644 index 000000000..3d2abf5ee --- /dev/null +++ b/julia/src/modal.jl @@ -0,0 +1,518 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Modal and radial routes: the state is (n_omega, n_modes); the response is evaluated +# at the transform's nodes, chunk by chunk, and projected back onto the modes. + +"""Settings and buffers both routes share: band, windows, tableau, controller.""" +function common_tables(c, host) + T = c.T + crop = host.array("crop", Int) .+ 1 + nt = length(host.array("window", Float64)) + nf = c.envelope ? nt : nt ÷ 2 + 1 + # Which band bin feeds each fine bin, zero for the padding: scattering a stage + # into the fine spectrum is then one pass that also clears the padding. + uncrop = zeros(Int, nf) + uncrop[crop] .= eachindex(crop) + merge(c, ( + crop=upload(c, crop), uncrop=upload(c, uncrop), + mask=upload(c, host.array("mask", Bool)), norm_mask=upload(c, host.array("norm_mask", Bool)), + weights=upload(c, host.array("weights", T)), uniform=all(==(1), host.array("weights", Float64)), + window=upload(c, host.array("window", T)), omega_window=upload(c, host.array("omega_window", T)), + carrier=upload(c, host.has("carrier") ? host.array("carrier", Complex{T}) : zeros(Complex{T}, 0)), + rate=host.array("rate", Float64), coarse_rate=host.array("coarse_rate", Float64), + a=host.array("a", Float64), b=host.array("b", Float64), e=host.array("e", Float64), + nodes_c=host.array("c", Float64), nt=nt, nf=nf, + split_active=c.split && any(!iszero, host.array("coarse_rate", Float64)), + )) +end + +function create_modal(c, host) + c = common_tables(c, host) + T, C = c.T, Complex{c.T} + nt, nf = c.nt, c.nf + synthesis = host.array("synthesis", Float64) + spatial = host.has("spatial_absorber") ? host.array("spatial_absorber", Float64) : zeros(0, 0) + # The translated rates are constant over a trial: an exactly absent loss needs no + # additive temporal transform; the accepted-step split stays separate. + in_stage = any(!iszero, spatial) || (!c.split && any(!iszero, c.rate)) + nw, nm = size(host.array("linear", ComplexF64)) + nn = size(synthesis, 2) + chunk = node_chunk(c, host.int("chunk"), nn, nt) + R = c.envelope ? C : T + # Synthesis and projection in the frequency domain, on the band's rows (`source_spectral!`), + # where the nodes are about as many as the modes, as radially: half the GEMM rows of + # the fine time grid's, and one projection for the response and both plasma streams. + # Not where the modes are few (a capillary's nodes would add transforms), nor beside + # Raman or an unsplit temporal collar, which read the modes' time signals. + spectral = !c.envelope && !host.flag("raman") && 2nm >= nn && + !(!c.split && any(!iszero, c.rate)) + # The analytic signal from the spectrum, as native forms it: the modes' doubled + # one-sided spectrum and one complex inverse transform, the nodes' analytic signal + # by the (real) synthesis, its real part the field. It replaces a real inverse and + # a forward and inverse pair over the nodes a source, and matches them to rounding + # (the synthesis commutes with the projection onto positive frequencies). An odd + # grid keeps the time-domain pair, whose middle-bin rule differs. + from_spectrum = !c.envelope && !spectral && iseven(nt) && + (c.analytic || (host.flag("raman") && !host.flag("raman_thg"))) + # Every inverse transform is unnormalised: its 1/nt is folded into the tables that + # read the time-domain field, the synthesis and the in-stage absorber. + c = merge(c, (spectral=spectral, from_spectrum=from_spectrum, spectral_absorber=upload(c, T.(spatial)), + # The operator stays binary64 at either precision, or a double-float where the + # device lacks binary64: propagators and the Adams flow are formed from it in + # that wide type and rounded once (SEP 33, 4.1 item 3). + linear=upload(c, widen_host(wide_eltype(c), host.array("linear", ComplexF64))), prefactor=upload(c, host.array("prefactor", C)), + synthesis=upload(c, T.(synthesis ./ nt)), projection=upload(c, host.array("projection", T)), + projection_coarse=upload(c, host.array("projection_coarse", T)), + embedded=host.flag("embedded"), spatial_absorber=upload(c, T.(spatial ./ nt)), + in_stage=in_stage, absorber_rate=upload(c, T.(-0.5 .* c.rate ./ nt)), + coarse_rate=upload(c, T.(c.coarse_rate)), nc=length(c.coarse_rate), + )) + ns = length(c.nodes_c) + fine = dzeros(c, C, nf, nm) + modal = dzeros(c, R, nt, nm) + nodes = dzeros(c, R, nt, chunk) + analytic = dzeros(c, C, nt, chunk) + analytic_modes = dzeros(c, C, from_spectrum ? nt : 0, from_spectrum ? nm : 0) + coarse = dzeros(c, R, c.nc, nm) + band = dzeros(c, C, nw, nm) + # The spectral path's buffers: a chunk's node spectra on the band and the fine grid, + # its polarisation's, and the band's projected source (and its coarse quadrature's). + node_band = dzeros(c, C, spectral ? nw : 0, spectral ? chunk : 0) + node_fine = dzeros(c, C, spectral ? nf : 0, spectral ? chunk : 0) + # On a GPU the forward streams are column blocks of one buffer, as native packs them: + # the projected source, the plasma's two currents, then their coarse quadratures. + # One transform takes a source's streams (with the quadrature, all six), where the + # streams' batches went through staging copies, the quadrature's a second time. + plasma = plasma_workspace(c, host, nt, chunk, nm, nn) + pack = nothing + if !oncpu(c) && !spectral && !c.envelope + streams = plasma === nothing ? 2 : 6 + half = streams ÷ 2 + pack_in, pack_out = dzeros(c, R, nt, streams * nm), dzeros(c, C, nf, streams * nm) + block(a, j) = view(a, :, (j-1)*nm+1:j*nm) + fine = block(pack_out, 1) + projected, projected_coarse = block(pack_in, 1), block(pack_in, half + 1) + coarse_spec = block(pack_out, half + 1) + if plasma !== nothing + plasma = merge(plasma, (projected=block(pack_in, 2), edge_projected=block(pack_in, 3), + coarse=block(pack_in, 5), coarse_edge=block(pack_in, 6), + spectrum=block(pack_out, 2), edge_spectrum=block(pack_out, 3), + coarse_spectrum=block(pack_out, 5), + coarse_edge_spectrum=block(pack_out, 6))) + end + source_in, source_out = view(pack_in, :, 1:half*nm), view(pack_out, :, 1:half*nm) + pack = (input=pack_in, output=pack_out, source_in=source_in, source_out=source_out, + source=plan(c, plan_rfft, source_in, 1), all=plan(c, plan_rfft, pack_in, 1)) + else + projected = dzeros(c, R, nt, spectral ? 0 : nm) + projected_coarse = dzeros(c, R, nt, spectral ? 0 : nm) + coarse_spec = similar(fine) + end + work = ( + node_band=node_band, node_fine=node_fine, band_source=dzeros(c, C, spectral ? nw : 0, spectral ? nm : 0), + band_coarse=dzeros(c, C, spectral ? nw : 0, spectral ? nm : 0), + node_inverse=spectral ? plan(c, plan_brfft, node_fine, nt, 1) : nothing, + node_forward=spectral ? plan(c, plan_rfft, nodes, 1) : nothing, + absorber_spec_band=dzeros(c, C, spectral && in_stage ? nw : 0, spectral && in_stage ? nm : 0), + adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), + monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), held_state=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), forward_stage=Ref{Any}(nothing), statistics=Ref{Any}(nothing), + raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma, pack=pack, + y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), + source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), + stages=dzeros(c, C, nw, nm, ns), forward=dzeros(c, C, nw, nm, ns), inverse=dzeros(c, C, nw, nm, ns), + fine=fine, modal=modal, nodes=nodes, analytic=analytic, analytic_modes=analytic_modes, + analytic_modes_inverse=from_spectrum ? plan(c, plan_bfft!, analytic_modes, 1) : nothing, + projected=projected, projected_coarse=projected_coarse, + coarse_spec=coarse_spec, absorber=dzeros(c, R, nt, spectral ? 0 : nm), absorber_spec=similar(fine), + coarse=coarse, + inverse_plan=c.envelope ? plan(c, plan_bfft, fine, 1) : plan(c, plan_brfft, fine, nt, 1), + forward_plan=c.envelope ? plan(c, plan_fft, modal, 1) : plan(c, plan_rfft, modal, 1), + analytic_forward=plan(c, plan_fft!, analytic, 1), analytic_inverse=plan(c, plan_bfft!, analytic, 1), + coarse_inverse=c.envelope ? plan(c, plan_bfft, band, 1) : plan(c, plan_brfft, band, c.nc, 1), + coarse_forward=c.envelope ? plan(c, plan_fft, coarse, 1) : plan(c, plan_rfft, coarse, 1), + ) + Engine(c, work, false, 0, NaN, c.factor, NaN, false, 1.0, 0) +end + +"""The modes' analytic signals from their half spectrum `fine`: the one-sided spectrum +doubled (the zero and Nyquist bins once, their real parts as the real inverse reads +them), the negative frequencies zero, and one unnormalised complex inverse in place: +`nt` times each mode's analytic signal, as the real inverse gives `nt` times its field.""" +function analytic_modes!(analytic, fine, inverse, c) + nt = size(analytic, 1) + half, nf, none = nt ÷ 2, size(fine, 1), zero(eltype(analytic)) + each!(c, size(analytic)...) do k, m + @inbounds begin + value = k <= nf ? fine[k, m] : none + analytic[k, m] = k == 1 || k == half + 1 ? complex(real(value)) : + k <= half ? 2 * value : none + end + end + inverse * analytic + nothing +end + +"""Place a band-limited state in the fine spectrum, clearing the padding.""" +function scatter!(fine, lab, c) + uncrop = c.uncrop + each!(c, size(fine)...) do k, m + @inbounds begin + f = uncrop[k] + fine[k, m] = f == 0 ? zero(eltype(fine)) : lab[f, m] + end + end +end + +"""Evaluate the translated source of `lab` into `work.source`: on a device that replays +graphs, the captured graph of this source when its host scalars are those it was +captured with (`graph_source!`), else each pass launched.""" +function source!(engine, lab; quadrature=false) + c = engine.config + if graph_ready(c) + sync_stage_values!(engine) + return graph_source!(engine, lab, quadrature) + end + source_launched!(engine, lab, quadrature) +end + +"""Whether the source kernels read their stage scalars from device memory.""" +graph_values(c) = graph_ready(c) + +"""Upload the stage scalars (`stage_slots`) where they changed: once a stage along a +gradient, never in a uniform medium.""" +function sync_stage_values!(engine) + c, p = engine.config, engine.work.plasma + current = Float64[engine.factor] + if p !== nothing + for channel in p.channels + push!(current, channel.parameters[8], channel.parameters[9]) + end + end + held = stage_slots(c, length(current)) + held.host == current && return nothing + held.host .= current + tally!(:upload) + held.staging .= current + copyto!(held.device, held.staging) + nothing +end + +function source_launched!(engine, lab, quadrature) + c = engine.config + c.free && return source_free!(engine, lab) + c.spectral && return source_spectral!(engine, lab, quadrature) + source_modal!(engine, lab, quadrature) +end + +"""Whether sources go through device graphs: a device whose extension captures them +(`graph_capture`), unless `SOLPROP_JULIA_GRAPH=0` or a timer that synchronises (which a +capture cannot contain) is on.""" +graph_ready(c) = !oncpu(c) && GRAPHS[] && graph_capable(c.backend) && + !(TIMING[] && !HOST_TIMING[]) && !KERNEL_TIMING[] + +"""The host values a captured source still holds: the taper (its products' alpha) and +whether the Kerr term is on. The stage's other scalars are device memory +(`stage_slots`), as are its prefactor and a rebuilt Raman kernel, all updated in +place, so a gradient's every stage replays one graph.""" +source_scalars(engine) = hash(engine.taper, hash(engine.factor != 0)) + +"""A source as a device graph: captured from the launched passes once the same buffers +and scalars have come round three times (by then every lazily made scratch, staging +buffer and plan exists, so the graph's pointers stay valid), then replayed. The replay +takes about 4 us of the host against 300 to 650 to launch the passes, and the device +runs them without the gaps between launches (`rdw` 386 against 962 us a source on an +A40, the same bits). A tapered guide, whose taper changes at every stage, keeps launching +its passes.""" +graph_source!(engine, lab, quadrature) = + replay_or_capture!(() -> source_launched!(engine, lab, quadrature), engine, + (:source_graph, objectid(lab), quadrature, source_scalars(engine))) + +"""Run `body`'s device work as a captured graph once `key` (the buffers, the shapes, the +host values the work holds) has come round three times, and replay it after; before, +or where the device cannot capture, run it as written. `body` evaluates `sources` +sources, which the replay counts.""" +function replay_or_capture!(body, engine, key; sources=1) + c = engine.config + graphs = c.scratch + exec = get(graphs, key, nothing) + if exec === nothing + seen = get(graphs, (:seen, key), 0) + 1 + # (A varying medium's keys never repeat: stop counting them past a bound.) + length(graphs) < 4096 && (graphs[(:seen, key)] = seen) + seen < 3 && return body() + calls = engine.calls + exec = graph_capture(c.backend, body) + engine.calls = calls + exec === nothing && return body() + graphs[key] = exec + tally!(:graph_capture) + end + tally!(:graph_replay) + graph_launch(exec) + engine.calls += sources + nothing +end + +function source_modal!(engine, lab, quadrature) + c, w = engine.config, engine.work + nm = size(lab, 2) + @section :scatter scatter!(w.fine, lab, c) + raman = w.raman + # The real modes where something reads them: the time-domain analytic signal, the + # in-stage absorber, a third-harmonic Raman's products. + real_modes = !c.from_spectrum || c.in_stage || + (raman !== nothing && raman.products && raman.thg) + real_modes && @section :inverse_fft mul!(w.modal, w.inverse_plan, w.fine) + c.from_spectrum && @section :inverse_fft analytic_modes!(w.analytic_modes, w.fine, + w.analytic_modes_inverse, c) + fill!(w.projected, 0) + quadrature && fill!(w.projected_coarse, 0) + clear_plasma!(w.plasma) + if engine.factor != 0 || w.plasma !== nothing || w.raman !== nothing + products = w.raman !== nothing && w.raman.products + products && @section :raman raman_products!(w.raman, w.modal, c; + signal=c.from_spectrum ? w.analytic_modes : nothing) + chunk, nn = size(w.nodes, 2), size(c.synthesis, 2) + for first in 1:chunk:nn + last = min(first + chunk - 1, nn) + count = last - first + 1 + nodes = @view w.nodes[:, 1:count] + if c.from_spectrum + # The nodes' analytic signal by the synthesis, the field its real part. + analytic = @view w.analytic[:, 1:count] + @section :synthesis gemm!(analytic, w.analytic_modes, @view(c.synthesis[:, first:last]), + engine.taper, false, c) + each!(c, size(analytic)...) do t, m + @inbounds nodes[t, m] = real(analytic[t, m]) + end + else + @section :synthesis gemm!(nodes, w.modal, @view(c.synthesis[:, first:last]), engine.taper, false, c) + end + if w.plasma !== nothing + @section :plasma plasma_current!(w.plasma, w.nodes, c, count) + @section :plasma_projection project_plasma!(w.plasma, c, first, last, quadrature, 1 / engine.taper) + end + products && @section :raman raman_nodal!(w.raman, first, last, c, engine.taper^2) + node_response!(engine, count) + @section :projection gemm!(w.projected, nodes, table_rows(c, c.projection, first, last), 1 / engine.taper, true, c) + quadrature && c.embedded && + gemm!(w.projected_coarse, nodes, table_rows(c, c.projection_coarse, first, last), 1 / engine.taper, true, c) + end + end + if w.pack !== nothing + # One transform: the source's streams, and with the quadrature its coarse ones, + # whose spectrum is assembled here for the alarm (`alarm_arrays`). + k = w.pack + coarse = quadrature && c.embedded + @section :forward_fft coarse ? mul!(k.output, k.all, k.input) : + mul!(k.source_out, k.source, k.source_in) + if w.plasma !== nothing + @section :plasma_spectrum add_plasma_spectra!(w.fine, w.plasma, c) + coarse && add_plasma_spectra!(w.coarse_spec, w.plasma, c; coarse=true) + end + elseif w.plasma === nothing + @section :forward_fft mul!(w.fine, w.forward_plan, w.projected) + else + # The source's and the currents' transforms as one pool's work. + p = w.plasma + @section :forward_fft transform_all!(w.forward_plan, (w.fine, p.spectrum, p.edge_spectrum), + (w.projected, p.projected, p.edge_projected), + w.forward_stage, c) + @section :plasma_spectrum add_plasma_spectra!(w.fine, p, c) + end + if c.in_stage + absorber!(w.absorber, w.modal, c) + isempty(c.spatial_absorber) || gemm!(w.absorber, w.modal, c.spatial_absorber, true, true, c) + mul!(w.absorber_spec, w.forward_plan, w.absorber) + end + @section :finish finish_source!(w.source, w.fine, c.in_stage ? w.absorber_spec : nothing, c) + engine.calls += 1 + nothing +end + +"""Kerr and Raman at a chunk's nodes, through the analytic signal where one is read.""" +function node_response!(engine, count) + c, w = engine.config, engine.work + nodes, raman = w.nodes, w.raman + if c.envelope + raman === nothing || raman_drive!(raman, nodes, nodes, c, count) + nonlinear_envelope!(nodes, c, engine.factor, raman, count) + elseif c.analytic || (raman !== nothing && !raman.thg && !raman.products) + # Formed from the spectrum already (`source!`), or here from the nodes. + c.from_spectrum || + @section :analytic analytic_signal!(w.analytic, nodes, w.analytic_forward, w.analytic_inverse, c, count) + raman === nothing || raman.products || @section :raman raman_drive!(raman, nodes, w.analytic, c, count) + @section :kerr nonlinear_nodes!(nodes, c.analytic ? w.analytic : nodes, c, engine.factor, raman, count) + else + raman === nothing || raman.products || @section :raman raman_drive!(raman, nodes, nodes, c, count) + @section :kerr nonlinear_nodes!(nodes, nodes, c, engine.factor, raman, count) + end +end + +"""The in-stage temporal collar's loss, `-alpha(t) E / 2`, unless the step splits it.""" +function absorber!(absorber, modal, c) + if c.split + fill!(absorber, 0) + else + rate = c.absorber_rate + each!(c, size(absorber)...) do t, m + @inbounds absorber[t, m] = rate[t] * modal[t, m] + end + end +end + +"""Scale the fine spectrum back onto the band: the prefactor and the omega window.""" +function finish_source!(source, fine, loss, c) + (; prefactor, omega_window, crop, mask) = c + live = loss !== nothing + extra = live ? loss : fine + each!(c, size(source)...) do f, m + @inbounds begin + k = crop[f] + value = prefactor[f, m] * omega_window[f] * fine[k, m] + if live && mask[f] + value += extra[k, m] + end + source[f, m] = value + end + end +end + +"""The source synthesised and projected on the band, chunk by chunk of nodes. + +The same arithmetic as `source!`, reordered: the synthesis and projection are linear +along the modes and the transforms along time, so each node's spectrum is the band's +modes times its synthesis row, and the source's band is the nodes' forward spectra +times the projection. A node's analytic signal is the inverse transform of its doubled +one-sided spectrum, whose real part is its field. The plasma's two streams join each +node's spectrum before the one projection, as in free space. +""" +function source_spectral!(engine, lab, quadrature) + c, w = engine.config, engine.work + (; node_band, node_fine, nodes, analytic, band_source, band_coarse) = w + nt, chunk = size(nodes) + nn = size(c.synthesis, 2) + fill!(band_source, 0) + quadrature && c.embedded && fill!(band_coarse, 0) + (; uncrop, crop) = c + T = real_type(engine) + unit, two, half = one(T), T(2), nt ÷ 2 + for first in 1:chunk:nn + last = min(first + chunk - 1, nn) + count = last - first + 1 + band = @view node_band[:, 1:count] + @section :synthesis gemm!(band, lab, @view(c.synthesis[:, first:last]), engine.taper, false, c) + if c.analytic + @section :analytic begin + each!(c, nt, chunk) do k, m + @inbounds begin + f = k <= half + 1 && m <= count ? uncrop[k] : 0 + weight = k == 1 || k == half + 1 ? unit : two + analytic[k, m] = f == 0 ? zero(eltype(analytic)) : weight * node_band[f, m] + end + end + w.analytic_inverse * analytic + each!(c, nt, chunk) do t, m + @inbounds nodes[t, m] = real(analytic[t, m]) + end + end + else + @section :inverse_fft begin + each!(c, size(node_fine)...) do k, m + @inbounds begin + f = m <= count ? uncrop[k] : 0 + node_fine[k, m] = f == 0 ? zero(eltype(node_fine)) : node_band[f, m] + end + end + mul!(nodes, w.node_inverse, node_fine) + end + end + w.plasma === nothing || @section :plasma plasma_current!(w.plasma, nodes, c, count) + @section :kerr nonlinear_nodes!(nodes, c.analytic ? analytic : nodes, c, engine.factor, nothing, count) + @section :forward_fft mul!(node_fine, w.node_forward, nodes) + @section :plasma_spectrum spectral_plasma!(node_band, node_fine, w.plasma, w.node_forward, c) + @section :projection begin + gemm!(band_source, band, table_rows(c, c.projection, first, last), 1 / engine.taper, true, c) + quadrature && c.embedded && + gemm!(band_coarse, band, table_rows(c, c.projection_coarse, first, last), 1 / engine.taper, true, c) + end + end + loss = nothing + if c.in_stage + # The spatial collar is linear and time-independent: its band is the state's + # band times the matrix. The spectral path runs only without a temporal one. + gemm!(w.absorber_spec_band, lab, c.spectral_absorber, true, false, c) + loss = w.absorber_spec_band + end + @section :finish finish_band!(w.source, band_source, loss, c) + engine.calls += 1 + nothing +end + +"""A chunk's band from its nodes' fine spectra, with the plasma streams joined.""" +function spectral_plasma!(band, fine, p, plan, c) + crop = c.crop + if p === nothing + each!(c, size(band)...) do f, m + @inbounds band[f, m] = fine[crop[f], m] + end + return nothing + end + mul!(p.spectrum, plan, p.gated) + mul!(p.edge_spectrum, plan, p.edge) + (; spectrum, edge_spectrum, inverse_omega) = p + mask = c.mask + each!(c, size(band)...) do f, m + @inbounds begin + k = crop[f] + value = fine[k, m] + if mask[f] + inverse = inverse_omega[f] + value += -im * inverse * spectrum[k, m] + inverse^2 * edge_spectrum[k, m] + end + band[f, m] = value + end + end +end + +"""The band's source: the prefactor and the omega window, and an in-stage loss.""" +function finish_band!(source, band, loss, c) + (; prefactor, omega_window, mask) = c + live = loss !== nothing + extra = live ? loss : band + each!(c, size(source)...) do f, m + @inbounds begin + value = prefactor[f, m] * omega_window[f] * band[f, m] + if live && mask[f] + value += extra[f, m] + end + source[f, m] = value + end + end +end + +"""A state given to an observation, at the engine's scale; `nothing` is its own state.""" +scaled_input(engine, ::Nothing) = engine.work.y +scaled_input(engine, input) = + device_matrix(engine, input) .* real_type(engine)(inv(engine.config.scale)) + +"""Observation populations of an accepted state: fractions, peaks and the six maxima.""" +function population_snapshot(engine, input) + engine.config.free && return population_free_snapshot(engine, input) + c, w = engine.config, engine.work + p = w.plasma + scatter!(w.fine, scaled_input(engine, input), c) + mul!(w.modal, w.inverse_plan, w.fine) + chunk, nn = size(w.nodes, 2), size(c.synthesis, 2) + maxima = zeros(6) + for first in 1:chunk:nn + last = min(first + chunk - 1, nn) + count = last - first + 1 + gemm!(@view(w.nodes[:, 1:count]), w.modal, @view(c.synthesis[:, first:last]), engine.taper, false, c) + each_channel(p) do q, _ + maxima .= max.(maxima, population_parts!(q, w.nodes, c, first, count)) + end + end + (channel_rows(p.fractions_all), channel_rows(p.peaks_all), maxima) +end diff --git a/julia/src/observe.jl b/julia/src/observe.jl new file mode 100644 index 000000000..52384ebc7 --- /dev/null +++ b/julia/src/observe.jl @@ -0,0 +1,490 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# What the driver reads of the state between steps: the state itself, and the boundary +# monitor's reductions, formed here so that only short vectors cross (SEP 21, ADR-057). + +"""The accepted state, for the host: the engine's own array on a CPU in binary64.""" +host_state(engine) = @section :observe host_view(engine.work.y) +host_candidate(engine) = host_view(engine.work.candidate) +host_view(a::Matrix{ComplexF64}) = a +host_view(a) = Matrix{ComplexF64}(Array(a)) + +"""A Python buffer's memory as a Julia array; the caller keeps the buffer alive.""" +host_wrap(buffer, T) = (array = PyArray{T}(buffer); unsafe_wrap(Array, pointer(array), size(array))) + +"""Copy a state between the engine and a host (n_omega, n_modes) column-major buffer. + +On a CPU the pool's tasks copy, each touching its own pages: a single-threaded copy +of a 226 MB Cartesian state into fresh host memory took 75-220 ms. +""" +function copy_between!(target, source, c) + if eltype(target) == eltype(source) && (oncpu(c) || !(target isa Array)) + pool_copy!(target, source, c) + else + copyto!(target, convert(Array{eltype(target)}, Array(source))) + end + target +end +function copy_state!(engine, buffer) + @section :observe begin + c, w = engine.config, engine.work + target = host_wrap(buffer, ComplexF64) + scale = engine.config.scale + if oncpu(c) + copy_between!(target, w.y, c) + scale == 1 || (target .*= scale) + elseif sizeof(w.y) > LARGE_STATE + # A large state straight into the reader's buffer, one pass (a binary32 one + # through a kept staging buffer, converted and scaled in one more): the held + # copy, a conversion and the reader's copy were three passes and two fresh + # allocations over a Cartesian state's 226 MB. + if eltype(w.y) == ComplexF64 + copyto!(target, w.y) + scale == 1 || (target .*= scale) + else + staging = get!(() -> similar(Array{eltype(w.y)}, size(w.y)), c.scratch, :host_state) + copyto!(staging, w.y) + target .= scale .* staging + end + else + # A small one copied once a state, however many readers ask (`version`): + # each copy is a wait on the device (about 0.2 ms on Metal). + held = w.held_state + if held[] === nothing || first(held[]) != engine.version + held[] = (engine.version, Matrix{ComplexF64}(Array(w.y))) + end + # (The operations of the compile trace: a new broadcast here compiled inside + # a timed window, about 8 ms on `rdw`.) + copyto!(target, last(held[])) + scale == 1 || (target .*= scale) + end + end + nothing +end +"""A state above this size (bytes) is copied to each reader directly, not held.""" +const LARGE_STATE = 16 * 2^20 + +"""Load a host state given as its (n_omega, n_modes) column-major view.""" +function load!(engine, input) + y = engine.work.y + source = host_wrap(input, ComplexF64) + inverse = inv(engine.config.scale) + c = engine.config + if oncpu(c) && eltype(y) == ComplexF64 && inverse == 1 + copy_between!(y, source, c) + elseif eltype(y) == ComplexF64 && inverse == 1 + # Straight to the device, one pass. + copyto!(y, source) + else + # Converted and scaled into a kept host buffer, then one copy up: the scaled + # copy, the conversion and a fresh device array were three passes. + staging = get!(() -> similar(Array{eltype(y)}, size(y)), c.scratch, :host_state) + staging .= source .* inverse + copyto!(y, staging) + end + reset!(engine) +end + +"""Hold the monitor's column weights and, for a split crossing, its rate buckets.""" +function bind_monitor!(engine, columns, buckets) + c, w = engine.config, engine.work + T = real_type(engine) + nm = size(w.y, 2) + weights = columns === nothing ? ones(T, nm) : T.(Vector{Float64}(columns)) + copyto!(w.monitor.columns, weights) + if buckets !== nothing + # The (n_omega, n_modes) view of the crossing's table, converted by the pool. + table = host_wrap(buckets, UInt8) + target = oncpu(c) ? w.monitor.buckets : similar(table, Int32) + each!(merge(c, (backend=KA.CPU(),)), size(table)...) do f, m + @inbounds target[f, m] = Int32(table[f, m]) + Int32(1) + end + oncpu(c) || copyto!(w.monitor.buckets, target) + end + nothing +end +function monitor_workspace(c, nw, nm, nc) + # Bucket one until a crossing binds its own: an index the histogram always holds. + (columns=dzeros(c, c.T, nm), buckets=fill!(dzeros(c, Int32, nw, nm), Int32(1)), power=dzeros(c, c.T, nc), + split=dzeros(c, c.T, nc), histogram=dzeros(c, c.T, 128, c.tasks)) +end + +"""Add `sum_m w_m |x(t, m)|^2 / n^2` of unnormalised inverse samples into `power`.""" +function add_power!(power, samples, weights, first, count, c) + T = eltype(power) + scale = inv(T(size(samples, 1)))^2 + rowsum!(c, power, size(samples, 1), count) do t, m + @inbounds abs2(samples[t, m]) * weights[first+m-1] * scale + end +end + +"""`P(t)` of the accepted state on the coarse time axis: the monitor's `power`.""" +state_power(engine) = @section :monitor monitor_power(engine) +function monitor_power(engine) + c, w = engine.config, engine.work + (; power, columns) = w.monitor + fill!(power, 0) + if c.free + chunk, nm = size(w.coarse, 2), size(w.y, 2) + for first in 1:chunk:nm + count = min(chunk, nm - first + 1) + columns_into!(w.coarse_spec, w.y, first, count, c) + mul!(w.coarse, w.coarse_inverse, w.coarse_spec) + add_power!(power, w.coarse, columns, first, count, c) + end + else + # The c2r transform overwrites its input: the scratch takes a copy. + pool_copy!(w.lab, w.y, c) + mul!(w.coarse, w.coarse_inverse, w.lab) + add_power!(power, w.coarse, columns, 1, size(w.y, 2), c) + end + Vector{Float64}(Array(power)) .* engine.config.scale^2 +end +split_power(engine) = Vector{Float64}(Array(engine.work.monitor.split)) .* engine.config.scale^2 + +function columns_into!(target, source, first, count, c) + each!(c, size(target)...) do f, m + @inbounds target[f, m] = m <= count ? source[f, first+m-1] : zero(eltype(target)) + end +end + +"""The state's spectral energy in each of the split crossing's rate buckets.""" +# A device's histogram a workgroup at a time in local memory, then added: every sample's +# atomic add on the few global buckets a crossing uses contended (747 us a radial +# occupancy on an AMD Instinct MI325X). +KA.@kernel function bucket_kernel!(histogram, @Const(y), @Const(buckets), @Const(columns), nw, n) + i = KA.@index(Global, Linear) + local_index = KA.@index(Local, Linear) + groupsize = KA.@groupsize()[1] + shared = KA.@localmem eltype(histogram) (128,) + b = local_index + while b <= 128 + @inbounds shared[b] = 0 + b += groupsize + end + KA.@synchronize + if i <= n + m = (i - 1) ÷ nw + 1 + f = i - (m - 1) * nw + @inbounds Atomix.@atomic shared[buckets[f, m]] += abs2(y[f, m]) * columns[m] + end + KA.@synchronize + b = local_index + while b <= 128 + @inbounds value = shared[b] + !iszero(value) && (@inbounds Atomix.@atomic histogram[b] += value) + b += groupsize + end +end + +function occupancy(engine) + c, w = engine.config, engine.work + (; buckets, columns, histogram) = w.monitor + y = w.y + nw, nm = size(y) + T = real_type(engine) + fill!(histogram, 0) + if oncpu(c) + tasks = size(histogram, 2) + @batch for k in 1:tasks + for m in k:tasks:nm, f in 1:nw + @inbounds histogram[buckets[f, m], k] += abs2(y[f, m]) * columns[m] + end + end + else + bucket_kernel!(c.backend, 256)(view(histogram, :, 1), y, buckets, columns, nw, + nw * nm; ndrange=nw * nm) + end + vec(sum(Array{Float64}(Array(histogram)); dims=2)) .* engine.config.scale^2 +end + +# --- the transverse edge (SEP 44): per-node and per-column energies ----------------- + +"""Set `out[m]` to the sum over `t` of `f(t, m)`: one column's reduction each.""" +function colsum!(f::F, c, out, nt::Integer, nm::Integer) where {F} + if !oncpu(c) + # A thread a column left most of the device idle: a parallel fill and a sum. + scratch = reduce_terms(f, c, out, nt, nm) + sum!(reshape(out, 1, :), scratch) + return nothing + end + each_column!(c, nm) do m + total = zero(eltype(out)) + @inbounds for t in 1:nt + total += f(t, m) + end + @inbounds out[m] = total + nothing + end +end + +"""Each spectral column's energy, `sum |E|^2` over frequency.""" +function column_energy(engine) + y = engine.work.y + out = dzeros(engine.config, real_type(engine), size(y, 2)) + colsum!(engine.config, out, size(y)...) do f, m + @inbounds abs2(y[f, m]) + end + Vector{Float64}(Array(out)) .* engine.config.scale^2 +end + +"""Hold a radial read's synthesis rows (0-based `rows` of `inverse`) for `node_energy`.""" +function bind_edge!(engine, inverse, rows) + c, y = engine.config, engine.work.y + T = real_type(engine) + selected = Vector{Int}(rows) .+ 1 + matrix = c.free ? nothing : upload(c, T.(permutedims(Matrix{Float64}(inverse)[selected, :]))) + engine.work.edge[] = (selected=selected, matrix=matrix, + synthesised=c.free ? nothing : dzeros(c, Complex{T}, size(y, 1), length(selected)), + energy=dzeros(c, T, c.free ? size(y, 2) : length(selected))) + nothing +end + +"""Each physical node's energy at the bound rows (`bind_edge!`), zero elsewhere: the +radial synthesis's rows, or every node of a Cartesian grid through the transverse +inverse transform.""" +node_energy(engine) = @section :edge edge_energy(engine) +function edge_energy(engine) + c, w = engine.config, engine.work + y, edge = w.y, w.edge[] + T = real_type(engine) + nodes = zeros(Float64, size(y, 2)) + out = edge.energy + if c.free + physical = w.physical + pool_copy!(physical, y, c) + transverse!(physical, w.spatial_inverse, c) + scale = inv(T(size(y, 2)))^2 + colsum!(c, out, size(y)...) do f, m + @inbounds abs2(physical[f, m]) * scale + end + all = Array(out) + nodes[edge.selected] .= all[edge.selected] + return nodes .* c.scale^2 + end + synthesised = edge.synthesised + gemm!(synthesised, y, edge.matrix, true, false, c) + colsum!(c, out, size(synthesised)...) do f, m + @inbounds abs2(synthesised[f, m]) + end + nodes[edge.selected] .= Array(out) + nodes .* c.scale^2 +end + +# --- the Poynting statistics' time-domain power ------------------------------------ + +"""Hold the Poynting statistics' buffers and their transform, and the power weight +(`weight`, (n_omega, n_modes)) and on-axis rows (`axis`, (2, n_modes), or `nothing`). +A varying guide's weight is bound again at each plane; nothing else changes.""" +function bind_poynting!(engine, weight, axis) + c, w = engine.config, engine.work + T = real_type(engine) + C = Complex{T} + nw, nm = size(w.y) + nt = c.nc + s = w.statistics[] + if s === nothing + signal = dzeros(c, C, nt, nm) + rows = axis === nothing ? nothing : upload(c, T.(permutedims(Matrix{Float64}(axis)))) + width = rows === nothing ? 0 : size(rows, 2) + s = (signal=signal, weighted=dzeros(c, C, nt, nm), weight=dzeros(c, T, nw, nm), + inverse=plan(c, plan_bfft!, signal, 1), rows=rows, + electric=dzeros(c, C, nt, width), magnetic=dzeros(c, C, nt, width), + power=dzeros(c, T, nt, nm), flux=dzeros(c, T, nt), + host_power=zeros(T, nt, nm), host_flux=zeros(T, rows === nothing ? 0 : nt)) + w.statistics[] = s + end + rebind_weight!(engine, weight) +end + +"""A new power weight (n_omega, n_modes) for the bound Poynting buffers: a varying +guide's, at each plane.""" +function rebind_weight!(engine, weight) + target = engine.work.statistics[].weight + copyto!(target, eltype(target).(Matrix{Float64}(weight))) + nothing +end + +"""The state's analytic power per mode and its on-axis flux, for the statistics. + +`stats._poynting_statistics`'s transforms: the analytic signals of the state and of +the state times its power weight, the cycle-averaged power `Re(a conj b)` per mode and +time, and with `flux` the on-axis flux through the bound rows. A field grid's analytic +signal keeps the zero-frequency and Nyquist bins once, as `fourier.analytic_signal` +does; an envelope's state already is one. Returns host arrays the engine reuses: the +power (n_t, n_modes) and the flux (n_t), in the state's physical units. +""" +function poynting!(engine, flux) + c, w = engine.config, engine.work + y, s = w.y, w.statistics[] + T = real_type(engine) + nw = size(y, 1) + nt, nm = size(s.signal) + (; signal, weighted, weight, power) = s + envelope, nyquist = c.envelope, nt ÷ 2 + 1 + unit, two, none = one(T), T(2), zero(Complex{T}) + for (target, weighting) in ((signal, false), (weighted, true)) + each!(c, nt, nm) do k, m + @inbounds begin + value = k <= nw ? y[k, m] * (weighting ? weight[k, m] : unit) : none + if !envelope + value = k == 1 || k == nyquist ? complex(real(value)) : k < nyquist ? two * value : none + end + target[k, m] = value + end + end + s.inverse * target + end + # Each inverse is unnormalised: numpy's 1/n_t on each signal, and the state scale. + factor = T((c.scale / nt)^2) + each!(c, nt, nm) do t, m + @inbounds power[t, m] = real(signal[t, m] * conj(weighted[t, m])) * factor + end + copyto!(s.host_power, power) + if flux + (; electric, magnetic, rows) = s + gemm!(electric, signal, rows, true, false, c) + gemm!(magnetic, weighted, rows, true, false, c) + values, start = s.flux, zero(T) + each!(c, nt, 1) do t, _ + @inbounds begin + value = start + for j in axes(electric, 2) + value += real(electric[t, j] * conj(magnetic[t, j])) + end + values[t] = value * factor + end + end + copyto!(s.host_flux, values) + end + (s.host_power, s.host_flux) +end + +const bind_poynting_b = bind_poynting! +const rebind_weight_b = rebind_weight! +const poynting_b = poynting! + +# --- the spatial routes' local statistics -------------------------------------------- + +"""Hold the spatial local statistics' buffers and tables: the closure's factor, the +conjugate axial admittance (`closure`, (n_omega, n_modes)), and a modal transform's +synthesis over the pad scale (`synthesis`, (n_nodes, n_modes)); a free transform's +nodes are its inverse transverse FFT. `chunk` nodes are transformed at a time.""" +function bind_spatial!(engine, closure, synthesis, chunk) + c, w = engine.config, engine.work + T = real_type(engine) + C = Complex{T} + nw, nm = size(w.y) + s = w.spatial[] + if s === nothing + S = synthesis === nothing ? nothing : + upload(c, T.(permutedims(Matrix{Float64}(synthesis)))) + nn = S === nothing ? nm : size(S, 2) + width = min(Int(chunk), nn) + signal = dzeros(c, C, c.nc, width) + s = (closure=dzeros(c, C, nw, nm), S=S, electric=dzeros(c, C, nw, nn), + magnetic=dzeros(c, C, nw, nn), weighted=dzeros(c, C, nw, nm), signal=signal, + other=dzeros(c, C, c.nc, width), inverse=plan(c, plan_bfft!, signal, 1), + fluence=dzeros(c, T, nn), magnitudes=dzeros(c, T, nn), peaks=dzeros(c, T, nn)) + w.spatial[] = s + end + copyto!(s.closure, C.(Matrix{ComplexF64}(closure))) + nothing +end + +"""The nodes' spectra of a modal-domain matrix `x` (n_omega, n_modes) into `nodes`.""" +function node_spectra!(nodes, x, s, engine) + c = engine.config + if s.S === nothing + copyto!(nodes, x) + transverse!(nodes, engine.work.spatial_inverse, c) + else + gemm!(nodes, x, s.S, true, false, c) + end +end + +"""`backends.spatial._local_statistics`'s transforms and sums, by the engine. + +Each node's field and closure (the field times the conjugate admittance) as analytic +signals, their cycle-averaged Poynting flux `I(t) = 0.5 eps0 c Re(E conj(H))`, and per +node its fluence `dt sum_t I`, the magnitude `0.5 eps0 c dt sum_t |E||H|` and the peak +of `I`. Returns the three per-node arrays (the reference's own forms the widths).""" +function spatial_local!(engine, dt, conversion) + c, w = engine.config, engine.work + s = w.spatial[] + T = real_type(engine) + y = w.y + (; closure, weighted, electric, magnetic, signal, other, fluence, magnitudes, peaks) = s + each!(c, size(y)...) do k, m + @inbounds weighted[k, m] = y[k, m] * closure[k, m] + end + node_spectra!(electric, y, s, engine) + node_spectra!(magnetic, weighted, s, engine) + nw, nn = size(electric) + nt, width = size(signal) + # numpy's 1/n_t on each inverse, the state's scale, a free transform's 1/N. + points = s.S === nothing ? prod(c.spatial_shape) : 1 + factor = T((c.scale / (nt * points))^2) + flux, step = T(conversion), T(dt) + envelope, nyquist = c.envelope, nt ÷ 2 + 1 + two, none, start, lowest = T(2), zero(Complex{T}), zero(T), T(-Inf) + for first in 1:width:nn + count = min(width, nn - first + 1) + for (target, source) in ((signal, electric), (other, magnetic)) + each!(c, nt, width) do k, n + @inbounds begin + value = k <= nw && n <= count ? source[k, first+n-1] : none + if !envelope + value = k == 1 || k == nyquist ? complex(real(value)) : + k < nyquist ? two * value : none + end + target[k, n] = value + end + end + s.inverse * target + end + if oncpu(c) + each_column!(c, count) do n + total, magnitude, peak = start, start, lowest + @inbounds for t in 1:nt + e, h = signal[t, n], other[t, n] + intensity = flux * real(e * conj(h)) * factor + total += intensity + magnitude += abs(e) * abs(h) * factor + peak = max(peak, intensity) + end + @inbounds begin + fluence[first+n-1] = step * total + magnitudes[first+n-1] = flux * step * magnitude + peaks[first+n-1] = peak + end + nothing + end + else + # A device's reductions over a parallel fill, not a thread a node. + fluxes = reduce_terms(c, fluence, nt, width) do t, n + @inbounds flux * real(signal[t, n] * conj(other[t, n])) * factor + end + products = reduce_terms(c, fluence, nt, width; use=:products) do t, n + @inbounds abs(signal[t, n]) * abs(other[t, n]) * factor + end + totals, sizes, highest = (scratch(c, use, T, 1, width) for use in (:totals, :sizes, :peaks)) + sum!(totals, fluxes) + sum!(sizes, products) + maximum!(highest, fluxes) + each!(c, count, 1) do n, _ + @inbounds begin + fluence[first+n-1] = step * totals[1, n] + magnitudes[first+n-1] = flux * step * sizes[1, n] + peaks[first+n-1] = highest[1, n] + end + end + end + end + (Vector{Float64}(Array(fluence)), Vector{Float64}(Array(magnitudes)), + Vector{Float64}(Array(peaks))) +end + +const bind_spatial_b = bind_spatial! +const spatial_local_b = spatial_local! diff --git a/julia/src/precompile_trace.jl b/julia/src/precompile_trace.jl new file mode 100644 index 000000000..6589eaebf --- /dev/null +++ b/julia/src/precompile_trace.jl @@ -0,0 +1,1608 @@ +precompile(Tuple{AcceleratedKernels.var"##Auto#5", Bool, Type{AcceleratedKernels.Auto}}) +precompile(Tuple{Adapt.var"##3#4", Vararg{Any, 4}}) +precompile(Tuple{ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_index)}, Int64}) +precompile(Tuple{ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_shape)}, Int64}) +precompile(Tuple{Base.Broadcast.var"#copy##0#copy##1"{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}}, Int64}) +precompile(Tuple{Base.Broadcast.var"#copy##0#copy##1"{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}}, Int64}) +precompile(Tuple{Base.Broadcast.var"#copy##0#copy##1"{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}}, Int64}) +precompile(Tuple{Base.Broadcast.var"#copy##0#copy##1"{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}}, Int64}) +precompile(Tuple{Base.Broadcast.var"#copy##0#copy##1"{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{3}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}}, Int64}) +precompile(Tuple{Base.Fix{2, typeof(Base.:(var"==")), Int64}, Int64}) +precompile(Tuple{Base.Iterators.var"#IteratorEltype##0#IteratorEltype##1"{Tuple{Array{PythonCall.Py, 1}, Array{Array{String, 1}, 1}}}, Int64}) +precompile(Tuple{Base.Iterators.var"#IteratorSize##0#IteratorSize##1"{Tuple{Array{PythonCall.Py, 1}, Array{Array{String, 1}, 1}}}, Int64}) +precompile(Tuple{Base.Iterators.var"#IteratorSize##2#IteratorSize##3"{Tuple{Array{Tuple{Int64, Int64}, 1}, Base.UnitRange{Int64}}}, Int64}) +precompile(Tuple{Base.Iterators.var"#IteratorSize##2#IteratorSize##3"{Tuple{Base.UnitRange{Int64}, Base.UnitRange{Int64}}}, Int64}) +precompile(Tuple{Base.JuliaSyntax.var"#invoke_fixedworld#95#fix_world_age##3"{typeof(Base.JuliaSyntax.core_parser_hook), UInt64}, Base.Pairs{Symbol, Union{}, Nothing, NamedTuple{(), Tuple{}}}, Base.JuliaSyntax.var"#invoke_fixedworld#fix_world_age##2"{Base.JuliaSyntax.var"#invoke_fixedworld#95#fix_world_age##3"{typeof(Base.JuliaSyntax.core_parser_hook), UInt64}}, Core.SimpleVector, Vararg{Any}}) +precompile(Tuple{Base.JuliaSyntax.var"#invoke_fixedworld#fix_world_age##2"{Base.JuliaSyntax.var"#invoke_fixedworld#95#fix_world_age##3"{typeof(Base.JuliaSyntax.core_parser_hook), UInt64}}, Core.SimpleVector, Vararg{Any}}) +precompile(Tuple{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Float64}, Int64}) +precompile(Tuple{BitTwiddlingConvenienceFunctions.var"##1#2", Any, Any, Any}) +precompile(Tuple{GPUCompiler.LowerGCFrame, LLVM.Function}) # recompile +precompile(Tuple{GPUCompiler.var"##275#276", Vararg{Any, 11}}) +precompile(Tuple{GPUCompiler.var"##emit_llvm#248", Bool, typeof(GPUCompiler.emit_llvm), GPUCompiler.CompilerJob{T, P} where P where T}) # recompile +precompile(Tuple{KernelAbstractions.POCL.var"#61#62"{typeof(KernelAbstractions.POCL.POCLKernels.gpu_fill_kernel), Base.Some{Type}, NamedTuple{(:name,), Tuple{Nothing}}}}) +precompile(Tuple{KernelAbstractions.var"##48#49", Any, Any, Any}) # recompile +precompile(Tuple{LayoutPointers.var"##1#2", Vararg{Any, 5}}) +precompile(Tuple{LLVM.Interop.var"##11#12", Vararg{Any, 10}}) # recompile +precompile(Tuple{LLVM.Interop.var"#14#15", LLVM.IRBuilder, Array{Any, 1}, Array{Any, 1}}) # recompile +precompile(Tuple{Main.var"#2#3", String}) +precompile(Tuple{ManualMemory.var"##1#2", Any, Any, Any}) +precompile(Tuple{ManualMemory.var"##3#4", Vararg{Any, 4}}) +precompile(Tuple{ManualMemory.var"##5#6", Any, Any, Any}) +precompile(Tuple{ManualMemory.var"##7#8", Vararg{Any, 5}}) +precompile(Tuple{ManualMemory.var"##9#10", Vararg{Any, 5}}) +precompile(Tuple{Polyester.var"##1#2", Vararg{Any, 9}}) +precompile(Tuple{Polyester.var"##6#7", Vararg{Any, 17}}) +precompile(Tuple{PythonCall.Convert.var"##19#20", Any, Any, Any}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Any, typeof(PythonCall.JlWrap.pyconvert_rule_jlvalue)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Array{Any, 1}, typeof(PythonCall.Convert.pyconvert_rule_iterable)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Array{Any, 1}, typeof(PythonCall.Convert.pyconvert_rule_iterable)}, PythonCall.Py}) # recompile +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Bool, typeof(PythonCall.Convert.pyconvert_rule_bool)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Float64, typeof(PythonCall.Convert.pyconvert_rule_float)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Integer, typeof(PythonCall.Convert.pyconvert_rule_int)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{NamedTuple{names, T} where T<:Tuple where names, typeof(PythonCall.Convert.pyconvert_rule_iterable)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{PythonCall.PyArray{T, N, M, L, R} where R where L where M where N where T, typeof(PythonCall.Wrap.pyconvert_rule_array_nocopy)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{PythonCall.PyDict{K, V} where V where K, typeof(PythonCall.Wrap.pyconvert_rule_mapping)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{String, typeof(PythonCall.Convert.pyconvert_rule_str)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Tuple, typeof(PythonCall.Convert.pyconvert_rule_iterable)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyisin#_pyconvert_get_rules##0", PythonCall.Py, Array{PythonCall.Py, 1}}) +precompile(Tuple{PythonCall.Utils.var"##4#5", Any, Any, Any}) +precompile(Tuple{PythonCall.Utils.var"##6#7", Any, Any, Any}) +precompile(Tuple{PythonCall.Utils.var"##8#9", Any, Any, Any}) +precompile(Tuple{SolpropJulia.var"#better#landing##0", Tuple{Float64, Int64, Float64}, Tuple{Float64, Int64, Float64}}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_bfft!), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_bfft), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_bfft!), Array{Base.Complex{Float64}, 3}, Tuple{Int64, Int64}}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_brfft), Array{Base.Complex{Float64}, 2}, Int64, Vararg{Int64}}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_fft!), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_fft), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_fft!), Array{Base.Complex{Float64}, 3}, Tuple{Int64, Int64}}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_rfft), Array{Float64, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, typeof(AbstractFFTs.plan_bfft!), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, typeof(AbstractFFTs.plan_brfft), Array{Base.Complex{Float64}, 2}, Int64, Vararg{Int64}}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, typeof(AbstractFFTs.plan_fft!), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, typeof(AbstractFFTs.plan_rfft), Array{Float64, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"#record#run_march##1"{SolpropJulia.var"#elapsed#run_march##0"{Float64}}, Float64, Float64, Float64, Bool, Int64}) +precompile(Tuple{StaticArrayInterface.var"##35#36", Vararg{Any, 12}}) +precompile(Tuple{StaticArrayInterface.var"##46#47", Vararg{Any, 5}}) +precompile(Tuple{StaticArrayInterface.var"#_accum_dims##0#_accum_dims##1"{Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}}, Int64}) +precompile(Tuple{StaticArrayInterface.var"#_accum_dims##0#_accum_dims##1"{Tuple{Int64, Int64}, Tuple{Int64, Int64}}, Int64}) +precompile(Tuple{StaticArrayInterface.var"#rank_to_sortperm##0#rank_to_sortperm##1"{Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}, Int64}) +precompile(Tuple{StaticArrayInterface.var"#rank_to_sortperm##0#rank_to_sortperm##1"{Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}, Int64}) +precompile(Tuple{Static.var"##49#50", Vararg{Any, 5}}) +precompile(Tuple{StrideArraysCore.var"##16#17", Any, Any, Any}) +precompile(Tuple{StrideArraysCore.var"##18#19", Any, Any, Any}) +precompile(Tuple{StrideArraysCore.var"##24#25", Any, Any}) +precompile(Tuple{StrideArraysCore.var"##26#27", Vararg{Any, 8}}) +precompile(Tuple{StrideArraysCore.var"##28#29", Vararg{Any, 8}}) +precompile(Tuple{StrideArraysCore.var"##30#31", Any, Any, Any}) +precompile(Tuple{StrideArraysCore.var"##32#33", Vararg{Any, 4}}) +precompile(Tuple{StrideArraysCore.var"##3#4", Vararg{Any, 4}}) +precompile(Tuple{StrideArraysCore.var"##45#46", Any, Any, Any}) +precompile(Tuple{StrideArraysCore.var"##5#6", Vararg{Any, 4}}) +precompile(Tuple{StrideArraysCore.var"##9#10", Any, Any, Any}) +precompile(Tuple{ThreadingUtilities.ThreadTask}) +precompile(Tuple{Type{Array{Base.Complex{Float64}, N} where N}, PythonCall.PyArray{Base.Complex{Float64}, 1, true, true, Base.Complex{Float64}}}) +precompile(Tuple{Type{Array{Base.Complex{Float64}, N} where N}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}}) +precompile(Tuple{Type{Array{Base.Complex{Float64}, N} where N}, PythonCall.PyArray{Base.Complex{Float64}, 3, true, false, Base.Complex{Float64}}}) +precompile(Tuple{Type{Array{Bool, N} where N}, PythonCall.PyArray{Bool, 1, true, true, Bool}}) +precompile(Tuple{Type{Array{Float64, 1}}, Array{Float64, 1}}) +precompile(Tuple{Type{Array{Float64, N} where N}, PythonCall.PyArray{Float64, 1, true, true, Float64}}) +precompile(Tuple{Type{Array{Float64, N} where N}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{Type{Array{Float64, N} where N}, PythonCall.PyArray{Float64, 2, true, true, Float64}}) +precompile(Tuple{Type{Array{Int64, N} where N}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{Type{Array{T, N} where N where T}, Array{Float64, 1}}) +precompile(Tuple{Type{Base.Fix{1, F, T} where T where F}, Type{Base.FilteringRF{F, T} where T where F}, Function}) +precompile(Tuple{Type{Base.Fix{1, F, T} where T where F}, typeof(tuple), Int64}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, KernelAbstractions.var"#67#68"{Tuple{}}, Base.UnitRange{Int64}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, PythonCall.Convert.var"#pyconvert_get_rules##0#pyconvert_get_rules##1", Array{PythonCall.Convert.PyConvertRule, 1}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, PythonCall.Convert.var"#pyconvert_get_rules##6#pyconvert_get_rules##7", Base.Iterators.Filter{PythonCall.Convert.var"#pyconvert_get_rules##8#pyconvert_get_rules##9", Base.Iterators.Enumerate{Array{PythonCall.Convert.PyConvertRule, 1}}}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, SolpropJulia.var"#28#29"{Int64, typeof(AbstractFFTs.plan_brfft), Array{Base.Complex{Float64}, 2}, Tuple{Int64, Int64}}, Array{Base.UnitRange{Int64}, 1}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.identity), Base.Iterators.Filter{PythonCall.Convert.var"#pyconvert_get_rules##4#pyconvert_get_rules##5", Array{PythonCall.Convert.PyConvertRule, 1}}}) +precompile(Tuple{Type{Base.Iterators.Filter{F, I} where I where F}, PythonCall.Convert.var"#pyconvert_get_rules##4#pyconvert_get_rules##5", Array{PythonCall.Convert.PyConvertRule, 1}}) +precompile(Tuple{Type{Base.Iterators.Filter{F, I} where I where F}, PythonCall.Convert.var"#pyconvert_get_rules##8#pyconvert_get_rules##9", Base.Iterators.Enumerate{Array{PythonCall.Convert.PyConvertRule, 1}}}) +precompile(Tuple{Type{Base.Iterators.Flatten{I} where I}, Base.Generator{Array{PythonCall.Convert.PyConvertRule, 1}, PythonCall.Convert.var"#pyconvert_get_rules##0#pyconvert_get_rules##1"}}) +precompile(Tuple{Type{Base.IteratorsMD.CartesianIndex{N} where N}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{Type{Base.KeyError}, Char}) +precompile(Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Array{Function, 1}}) +precompile(Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Array{PythonCall.Convert.PyConvertRule, 1}}) +precompile(Tuple{Type{Base.Returns{V} where V}, Base.OneTo{Int64}}) +precompile(Tuple{Type{Base.Val{x} where x}, Tuple{Int64}}) +precompile(Tuple{Type{Base.Val{x} where x}, Tuple{Int64, Int64}}) +precompile(Tuple{Type{Base.Val{x} where x}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{Type{Int128}, UInt64}) +precompile(Tuple{Type{NamedTuple{(:array, :buffer, :copy), T} where T<:Tuple}, Tuple{Bool, Bool, Bool}}) +precompile(Tuple{Type{NamedTuple{(:copy,), T} where T<:Tuple}, Tuple{Bool}}) +precompile(Tuple{Type{NamedTuple{(:dense_buffer,), T} where T<:Tuple}, Tuple{Bool}}) +precompile(Tuple{Type{NamedTuple{(:dims, :init, :backend), T} where T<:Tuple}, Tuple{Int64, Float64, KernelAbstractions.POCL.POCLKernels.POCLBackend}}) +precompile(Tuple{Type{NamedTuple{(:dims, :init), T} where T<:Tuple}, Tuple{Int64, Float64}}) +precompile(Tuple{Type{NamedTuple{(:direct,), T} where T<:Tuple}, Tuple{Bool}}) +precompile(Tuple{Type{NamedTuple{(:heavy,), T} where T<:Tuple}, Tuple{Bool}}) +precompile(Tuple{Type{NamedTuple{(:init, :seed, :dims, :inclusive), T} where T<:Tuple}, Tuple{Float64, Float64, Int64, Bool}}) +precompile(Tuple{Type{NamedTuple{(:min,), T} where T<:Tuple}, Tuple{Int64}}) +precompile(Tuple{Type{NamedTuple{(:quadrature,), T} where T<:Tuple}, Tuple{Bool}}) +precompile(Tuple{Type{NamedTuple{(:use,), T} where T<:Tuple}, Tuple{Symbol}}) +precompile(Tuple{typeof(AcceleratedKernels.exact_neutral), typeof(Base.:(+)), Float64}) +precompile(Tuple{typeof(AcceleratedKernels.iswhole), Function}) +precompile(Tuple{typeof(ArrayInterface.ndims_index), Type{var"#s15"} where var"#s15"<:(AbstractArray{T, N} where N where T)}) +precompile(Tuple{typeof(ArrayInterface.ndims_shape), Type{var"#s15"} where var"#s15"<:(AbstractArray{T, N} where N where T)}) +precompile(Tuple{typeof(Artifacts.__artifact_str), Module, String, Base.SubString{String}, String, Base.Dict{String, Any}, Base.SHA1, Base.BinaryPlatforms.Platform, Base.Val{LazyArtifacts}}) +precompile(Tuple{typeof(Artifacts._artifact_str), Module, String, Base.SubString{String}, String, Base.Dict{String, Any}, Base.SHA1, Base.BinaryPlatforms.Platform, Base.Val{LazyArtifacts}}) +precompile(Tuple{typeof(Base.abs), Base.Complex{Float64}}) +precompile(Tuple{typeof(Base.abs), Int32}) +precompile(Tuple{typeof(Base.add_sum), Bool, Bool}) +precompile(Tuple{typeof(Base.add_sum), Float64, Float64}) +precompile(Tuple{typeof(Base._all), Base.Fix{2, typeof(Base.:(var"==")), Int64}, Array{Float64, 1}, Base.Colon}) +precompile(Tuple{typeof(Base.all), Function, Array{Float64, 1}}) +precompile(Tuple{typeof(Base.all), Function, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base._any), Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, Array{Float64, 1}, Base.Colon}) +precompile(Tuple{typeof(Base._any), Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, Array{Float64, 2}, Base.Colon}) +precompile(Tuple{typeof(Base.any), Function, Array{Float64, 1}}) +precompile(Tuple{typeof(Base.any), Function, Array{Float64, 2}}) +precompile(Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Type}) +precompile(Tuple{typeof(Base.append!), Array{Float64, 1}, NTuple{6, Float64}}) +precompile(Tuple{typeof(Base._array_for), Type{Function}, Array{PythonCall.Convert.PyConvertRule, 1}, Base.HasShape{1}}) +precompile(Tuple{typeof(Base._array_for), Type{PythonCall.Convert.PyConvertRule}, Array{PythonCall.Convert.PyConvertRule, 1}, Base.HasShape{1}}) +precompile(Tuple{typeof(Base._atexit), Int32}) # recompile +precompile(Tuple{typeof(Base.axes), Array{PythonCall.Convert.PyConvertRule, 1}, Int64}) +precompile(Tuple{typeof(Base.:(-)), Base.Complex{Bool}}) +precompile(Tuple{typeof(Base.:(>)), Base.VersionNumber, Base.VersionNumber}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Base.Complex{Float64}}, Array{Base.Complex{Float64}, 1}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Float64}, Array{Float64, 1}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Float64}, Array{Float64, 2}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Float64}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.inv), Tuple{Array{Float64, 1}}}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Float64}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(/)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Float64, Array{Float64, 1}}}, Int64}}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Float64}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(Base.:(/)), Tuple{Array{Float64, 2}, Int64}}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Int64}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Array{Base.Complex{Float64}, 1}, Float64}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Array{Float64, 1}, Float64}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(/)), Array{Float64, 2}, Int64}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), Array{Int64, 1}, Int64}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(/)), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Float64, Array{Float64, 1}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Float64, Array{Float64, 1}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.float), Tuple{Float64, Float64}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.identity), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.identity), Base.OneTo{Int64}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.inv), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Tuple{Int64}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{3}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Float64, Int64}) +precompile(Tuple{typeof(Base.Broadcast.broadcast_shape), Tuple{Base.OneTo{Int64}}, Tuple{}}) +precompile(Tuple{typeof(Base.Broadcast.broadcast_shape), Tuple{}, Tuple{Base.OneTo{Int64}}}) +precompile(Tuple{typeof(Base.Broadcast._getindex), Tuple{Int64}, Int64}) +precompile(Tuple{typeof(Base.Broadcast.materialize!), Array{Base.Complex{Float64}, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Array{Base.Complex{Float64}, 1}, Float64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize!), Array{Float64, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Array{Float64, 1}, Float64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Base.Complex{Float64}}, Tuple{Array{Base.Complex{Float64}, 1}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Float64}, Tuple{Array{Float64, 1}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Float64}, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.inv), Tuple{Array{Float64, 1}}}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Float64}, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(/)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Float64, Array{Float64, 1}}}, Int64}}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Array{Base.Complex{Float64}, 1}, Float64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(+)), Tuple{Array{Int64, 1}, Int64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, Type{Float64}, Tuple{Array{Float64, 2}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, Type{Float64}, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(Base.:(/)), Tuple{Array{Float64, 2}, Int64}}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(Base.:(/)), Tuple{Array{Float64, 2}, Int64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, Type{Int64}, Tuple{Tuple{Int64, Int64}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.float), Tuple{Tuple{Float64, Float64}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(*)), Tuple{Tuple{Int64}, Int64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Array{Int64, 1}}, false}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Array{Float64, 1}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Array{Int64, 1}}, false}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.OneTo{Int64}}}}) +precompile(Tuple{typeof(Base.Cartesian._nloops), Int64, Symbol, Bool, Symbol, Expr, Vararg{Expr}}) +precompile(Tuple{typeof(Base.__cat), Array{Bool, 1}, Tuple{Int64}, Tuple{Bool}, Array{Bool, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base.__cat), Array{Float64, 1}, Tuple{Int64}, Tuple{Bool}, Array{Float64, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base.__cat), Array{Int64, 1}, Tuple{Int64}, Tuple{Bool}, Array{Int64, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base.__cat_offset!), Array{Bool, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Array{Bool, 1}, Bool}) +precompile(Tuple{typeof(Base.__cat_offset!), Array{Float64, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Array{Float64, 1}, Float64}) +precompile(Tuple{typeof(Base.__cat_offset!), Array{Int64, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Array{Int64, 1}, Int64}) +precompile(Tuple{typeof(Base.cat_similar), Array{Bool, 1}, Type{Bool}, Tuple{Int64}}) +precompile(Tuple{typeof(Base.cat_similar), Array{Float64, 1}, Type{Float64}, Tuple{Int64}}) +precompile(Tuple{typeof(Base.cat_similar), Array{Int64, 1}, Type{Int64}, Tuple{Int64}}) +precompile(Tuple{typeof(Base.cat_size_shape), Tuple{Bool}, Array{Bool, 1}, Bool}) +precompile(Tuple{typeof(Base.cat_size_shape), Tuple{Bool}, Array{Float64, 1}, Float64}) +precompile(Tuple{typeof(Base.cat_size_shape), Tuple{Bool}, Array{Int64, 1}, Int64}) +precompile(Tuple{typeof(Base._cat_t), Base.Val{1}, Type{Bool}, Array{Bool, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base._cat_t), Base.Val{1}, Type{Float64}, Array{Float64, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base._cat_t), Base.Val{1}, Type{Int64}, Array{Int64, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base.cconvert), Type{Ptr{LLVM.API.JLOpaqueJuliaOJIT}}, LLVM.JuliaOJIT}) +precompile(Tuple{typeof(Base.cconvert), Type{Ptr{LLVM.API.LLVMOpaqueModule}}, LLVM.Module}) +precompile(Tuple{typeof(Base._check_valid_region), Int64}) +precompile(Tuple{typeof(Base.collect), Base.Generator{Array{Base.UnitRange{Int64}, 1}, SolpropJulia.var"#28#29"{Int64, typeof(AbstractFFTs.plan_brfft), Array{Base.Complex{Float64}, 2}, Tuple{Int64, Int64}}}}) +precompile(Tuple{typeof(Base.collect), Base.Generator{Base.Iterators.Filter{PythonCall.Convert.var"#pyconvert_get_rules##4#pyconvert_get_rules##5", Array{PythonCall.Convert.PyConvertRule, 1}}, typeof(Base.identity)}}) +precompile(Tuple{typeof(Base.collect), Base.Generator{Base.Iterators.Filter{PythonCall.Convert.var"#pyconvert_get_rules##8#pyconvert_get_rules##9", Base.Iterators.Enumerate{Array{PythonCall.Convert.PyConvertRule, 1}}}, PythonCall.Convert.var"#pyconvert_get_rules##6#pyconvert_get_rules##7"}}) +precompile(Tuple{typeof(Base.collect), Base.Iterators.Flatten{Base.Generator{Array{PythonCall.Convert.PyConvertRule, 1}, PythonCall.Convert.var"#pyconvert_get_rules##0#pyconvert_get_rules##1"}}}) +precompile(Tuple{typeof(Base.Compiler.add_edges_impl), Array{Any, 1}, Base.Compiler.ConstCallInfo}) # recompile +precompile(Tuple{typeof(Base.Compiler.add_edges_impl), Array{Any, 1}, Base.Compiler.MethodMatchInfo}) # recompile +precompile(Tuple{typeof(Base.Compiler.compute_inlining_cost), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.InferenceResult, Base.Compiler.OptimizationResult}) +precompile(Tuple{typeof(Base.Compiler.doworkloop), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.InferenceState}) +precompile(Tuple{typeof(Base.Compiler.finish!), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.InferenceState, UInt64, UInt64}) +precompile(Tuple{typeof(Base.Compiler.finish_nocycle), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.InferenceState, UInt64}) +precompile(Tuple{typeof(Base.Compiler.instanceof_tfunc), Any, Bool, Core.PartialStruct}) +precompile(Tuple{typeof(Base.Compiler.optimize), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.OptimizationState{GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}}, Base.Compiler.InferenceResult}) +precompile(Tuple{typeof(Base.Compiler.typeinf_code), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Core.MethodInstance, Bool}) +precompile(Tuple{typeof(Base.Compiler.typeinf_local), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.InferenceState, Base.Compiler.CurrentState}) +precompile(Tuple{typeof(Base.convert), Type{Number}, Int64}) +precompile(Tuple{typeof(Base.convert), Type{Ptr{Nothing}}, Ptr{Nothing}}) +precompile(Tuple{typeof(Base.copy!), Array{Any, 1}, Array{Any, 1}}) +precompile(Tuple{typeof(Base.copyto!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}) +precompile(Tuple{typeof(Base.copyto!), Array{Float64, 1}, Array{Float64, 1}}) +precompile(Tuple{typeof(Base.copyto!), Array{Float64, 2}, Array{Float64, 2}}) +precompile(Tuple{typeof(Base.copyto!), Array{Int64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(Base._cshp), Int64, Tuple{Bool}, Tuple{}, Tuple{Int64}}) +precompile(Tuple{typeof(Base.cumsum), Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.cumsum), Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base.deleteat!), Array{Symbol, 1}, Base.UnitRange{Int64}}) +precompile(Tuple{typeof(Base.eachindex), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.eachindex), Core.SimpleVector}) +precompile(Tuple{typeof(Base.:(*)), FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Base.Complex{Float64}, 2}}) +precompile(Tuple{typeof(Base.findfirst), Function, NTuple{7, Symbol}}) +precompile(Tuple{typeof(Base.findfirst), Function, Tuple{Int64}}) +precompile(Tuple{typeof(Base.findfirst), Function, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.findfirst), Function, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base._findfirst_rec), Base.Fix{2, typeof(Base.:(var"==")), Int64}, Int64, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base._findfirst_rec), Base.Fix{2, typeof(Base.:(var"==")), Symbol}, Int64, NTuple{7, Symbol}}) +precompile(Tuple{typeof(Base.:(>)), Float64, Float64}) +precompile(Tuple{typeof(Base.:(>=)), Float64, Float64}) +precompile(Tuple{typeof(Base.get), Base.IOStream, Symbol, Bool}) +precompile(Tuple{typeof(Base.getindex), Array{Bool, 1}, Base.UnitRange{Int64}}) +precompile(Tuple{typeof(Base.getindex), Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(Base.getindex), Array{Float64, 1}, Base.UnitRange{Int64}}) +precompile(Tuple{typeof(Base.getindex), Array{Float64, 1}, Int64}) +precompile(Tuple{typeof(Base.getindex), Array{Float64, 2}, Int64, Int64}) +precompile(Tuple{typeof(Base.getindex), Array{Int64, 1}, Base.UnitRange{Int64}}) +precompile(Tuple{typeof(Base.getindex), Array{PythonCall.Convert.PyConvertRule, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(Base.getindex), Array{PythonCall.Convert.PyConvertRule, 1}, Int64}) +precompile(Tuple{typeof(Base.getindex), Base.RefValue{Any}}) +precompile(Tuple{typeof(Base.getindex), Core.SimpleVector, Base.UnitRange{Int64}}) +precompile(Tuple{typeof(Base.getindex), Type{Int64}, Int64, Int64, Int64, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(Base.getindex), Type{Union{Nothing, LLVM.Metadata}}, LLVM.DIFile, LLVM.MDString, Nothing, Nothing, Vararg{Nothing}}) +precompile(Tuple{typeof(Base.getproperty), AcceleratedKernels.AccOp{Float64, typeof(Base.:(+))}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), AcceleratedKernels.CPUThreads.Partitioned, Symbol}) +precompile(Tuple{typeof(Base.getproperty), AcceleratedKernels.OptionalOp{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), AcceleratedKernels.OptionalOp{typeof(Base.:(+))}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{AcceleratedKernels.OptionalOp{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{AcceleratedKernels.OptionalOp{typeof(Base.:(+))}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{Base.var"#foreach##0#foreach##1"{SolpropJulia.var"#clear_plasma!##0#clear_plasma!##1"}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{Base.var"#foreach##0#foreach##1"{SolpropJulia.var"#reset_work!##0#reset_work!##1"}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{Base.var"#foreach##2#foreach##3"{typeof(Base.copyto!)}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{PythonCall.Utils.var"#explode_union##0#explode_union##1"}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{typeof(Base.Checked.checked_mul)}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{typeof(Base.GMP.MPZ.add!)}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{3}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.IteratorsMD.CartesianIndex{3}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.IteratorsMD.CartesianIndices{0, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.MappingRF{typeof(Base.identity), typeof(Base.mul_prod)}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.MappingRF{typeof(Base.:(-)), typeof(Base.max)}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), KernelAbstractions.Kernel{KernelAbstractions.POCL.POCLKernels.POCLBackend, KernelAbstractions.NDIteration.DynamicSize, KernelAbstractions.NDIteration.DynamicSize, typeof(KernelAbstractions.POCL.POCLKernels.gpu_fill_kernel)}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Markdown.MD, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:selected, :matrix, :synthesised, :energy), Tuple{Array{Int64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:selected, :matrix, :synthesised, :energy), Tuple{Array{Int64, 1}, Nothing, Nothing, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:signal, :weighted, :weight, :inverse, :rows, :electric, :magnetic, :power, :flux, :host_power, :host_flux), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:signal, :weighted, :weight, :inverse, :rows, :electric, :magnetic, :power, :flux, :host_power, :host_flux), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##2#rk4!##3"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##4#rk4!##5"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##6#rk4!##7"{Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#weighted_norm##0#weighted_norm##1"{Array{Base.Complex{Float64}, 2}, Float64, Float64, Float64, Array{Bool, 1}, Array{Float64, 1}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#combine!##4#combine!##5"{Int64, Tuple{Float64, Float64, Float64}, NTuple{7, Float64}, NTuple{7, Float64}, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#band_alarm##0#band_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#quadrature_alarm##0#quadrature_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 3, (1, 2, 3), Tuple{Int64, Int64, Int64}, Tuple{Nothing, Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 3, (1, 2, 3), Tuple{Int64, Int64, Int64}, Tuple{Nothing, Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#column_energy##0#column_energy##1"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##0#edge_energy##1"{Float64, Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##2#edge_energy##3"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#plasma_columns!##0#plasma_columns!##1"{Array{Float64, 2}, Int64, Float64, Float64, Float64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#population_columns!##0#population_columns!##1"{Array{Float64, 2}, Int64, Float64, Int64, Int64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#spatial_local!##4#spatial_local!##5"{Float64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#absorber!##0#absorber!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#add_plasma_spectra!##0#add_plasma_spectra!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##2#analytic_signal!##3"{Array{Base.Complex{Float64}, 2}, Float64, Int64, Float64, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#bind_monitor!##0#bind_monitor!##1"{Array{Int32, 2}, Array{UInt8, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#collar_factor##0#collar_factor##1"{Array{Float64, 1}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#columns_into!##0#columns_into!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#convolve!##0#convolve!##1"{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#finish_band!##0#finish_band!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#finish_source!##0#finish_source!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_propagators!##0#free_propagators!##1"{Float64, Bool, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#gather_columns!##0#gather_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Int64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#integrate_samples!##0#integrate_samples!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Float64, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#mask!##0#mask!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#material_stage!##0#material_stage!##1"{Int64, Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_envelope!##0#nonlinear_envelope!##1"{Array{Float64, 2}, Bool, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Float64, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#path_propagators!##0#path_propagators!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##0#plasma_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##2#plasma_samples!##3"{Array{Float64, 2}, Float64, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##4#plasma_samples!##5"{Array{Float64, 2}, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Base.SubArray{Base.Complex{Float64}, 2, Array{Base.Complex{Float64}, 3}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.Slice{Base.OneTo{Int64}}, Int64}, true}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##0#population_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##2#population_samples!##3"{Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##4#population_samples!##5"{Array{Float64, 2}, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##6#population_samples!##7"{Float64, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##0#poynting!##1"{Base.Complex{Float64}, Float64, Float64, Int64, Bool, Array{Float64, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##2#poynting!##3"{Float64, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##4#poynting!##5"{Float64, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#propagators!##2#propagators!##3"{NTuple{7, Float64}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Int64, Bool, Array{Float64, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Float64, 2}, Int64, Bool, Array{Float64, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_products!##0#raman_products!##1"{Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#rk4!##0#rk4!##1"{Float64, Float64, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#scatter!##0#scatter!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#scatter_columns!##0#scatter_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64, Array{Int64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##8#source_free!##9"{Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##0#source_spectral!##1"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##10#source_spectral!##11"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##2#source_spectral!##3"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##4#source_spectral!##5"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##6#source_spectral!##7"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##8#source_spectral!##9"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spatial_local!##0#spatial_local!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spatial_local!##2#spatial_local!##3"{Base.Complex{Float64}, Float64, Int64, Bool, Int64, Int64, Int64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spectral_plasma!##2#spectral_plasma!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##2#split_free!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#trial!##2#trial!##3"{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, NTuple{6, Float64}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#trial!##4#trial!##5"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Int64, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#occupancy##0#occupancy##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Int32, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Int32}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#rowsum!##0#rowsum!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}, SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Int64, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#rowsum!##0#rowsum!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}, SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Float64, 2}, Array{Float64, 1}, Int64, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#transform_all!##0#transform_all!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, typeof(SolpropJulia.transform_block!), SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Tuple{StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}, Tuple{StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), PythonCall.Convert.PyConvertRule, Symbol}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Any}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Array{Any, 1}}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Array{Int64, 1}}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Base.Dict{Symbol, Any}}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Bool}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Int64}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{String}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Tuple{Vararg{Symbol}}}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{UInt64}}) +precompile(Tuple{typeof(Base.ifelse), Bool, Base.Missing, Nothing}) +precompile(Tuple{typeof(Base.indexed_iterate), Pair{String, Bool}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Pair{String, Bool}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Int64, typeof(DataType)}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Int64, typeof(DataType)}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Nothing, Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Polyester.CombineIndices, Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Polyester.CombineIndices, Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Polyester.NoLoop, Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Polyester.NoLoop, Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Static.StaticInt{1}, Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Static.StaticInt{1}, Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Tuple{}, Base._InitialValue}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Tuple{}, Base._InitialValue}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.identity), AcceleratedKernels.AccOp{Float64, typeof(Base.:(+))}}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.identity), AcceleratedKernels.AccOp{Float64, typeof(Base.:(+))}}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.identity), AcceleratedKernels.OptionalOp{typeof(Base.:(+))}}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.identity), AcceleratedKernels.OptionalOp{typeof(Base.:(+))}}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.:(+)), Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.:(+)), Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(SolpropJulia.transform_block!), Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(SolpropJulia.transform_block!), Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(SolpropJulia.trial!), Tuple{typeof(DataType), typeof(DataType)}}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(SolpropJulia.trial!), Tuple{typeof(DataType), typeof(DataType)}}, Int64, Int64}) +precompile(Tuple{typeof(Base.in), Symbol, NTuple{7, Symbol}}) +precompile(Tuple{typeof(Base.:(+)), Int128, Int64}) +precompile(Tuple{typeof(Base.:(-)), Int128, Int64}) +precompile(Tuple{typeof(Base.:(*)), Int64, Static.StaticInt{1}}) +precompile(Tuple{typeof(Base.:(+)), Int64, Static.StaticInt{1}}) +precompile(Tuple{typeof(Base.:(-)), Int64, Static.StaticInt{1}}) +precompile(Tuple{typeof(Base.:(<)), Int64, Static.StaticInt{1}}) +precompile(Tuple{typeof(Base.:(<)), Int64, Static.StaticInt{2}}) +precompile(Tuple{typeof(Base.:(<)), Int64, Static.StaticInt{3}}) +precompile(Tuple{typeof(Base.:(-)), Int64, UInt32}) +precompile(Tuple{typeof(Base.:(*)), Int64, UInt64}) +precompile(Tuple{typeof(Base._in_tuple), Int64, Tuple, Bool}) +precompile(Tuple{typeof(Base._in_tuple), Type, Tuple, Bool}) +precompile(Tuple{typeof(Base.in), Type, NTuple{11, typeof(DataType)}}) +precompile(Tuple{typeof(Base.in), Type, NTuple{12, typeof(DataType)}}) +precompile(Tuple{typeof(Base.in), Type, NTuple{16, typeof(DataType)}}) +precompile(Tuple{typeof(Base.in), Type, NTuple{4, typeof(DataType)}}) +precompile(Tuple{typeof(Base.isempty), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.ispow2), Int64}) +precompile(Tuple{typeof(Base.issorted), Array{String, 1}, Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}}) +precompile(Tuple{typeof(Base.iterate), Array{PythonCall.Convert.PyConvertRule, 1}}) +precompile(Tuple{typeof(Base.iterate), Array{PythonCall.Convert.PyConvertRule, 1}, Int64}) +precompile(Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, KernelAbstractions.var"#67#68"{Tuple{}}}}) +precompile(Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, KernelAbstractions.var"#67#68"{Tuple{}}}, Int64}) +precompile(Tuple{typeof(Base.iterate), Base.Iterators.Enumerate{Core.SimpleVector}}) +precompile(Tuple{typeof(Base.iterate), Base.Iterators.Enumerate{Core.SimpleVector}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.Iterators.enumerate), Array{PythonCall.Convert.PyConvertRule, 1}}) +precompile(Tuple{typeof(Base.Iterators.enumerate), Core.SimpleVector}) +precompile(Tuple{typeof(Base.JuliaSyntax.core_parser_hook), Core.SimpleVector, String, Int64, Int64, Symbol}) +precompile(Tuple{typeof(Base.lastindex), Array{Bool, 1}}) +precompile(Tuple{typeof(Base.lastindex), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.last), Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.last), Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base.length), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.Libc.Libdl.dlopen), FFTW.FakeLazyLibrary}) +precompile(Tuple{typeof(Base.Libc.Libdl.dlsym), Ptr{Nothing}, Symbol}) +precompile(Tuple{typeof(Base._mapreduce), typeof(Base.abs), typeof(Base.max), Base.IndexLinear, Array{Base.Complex{Float64}, 1}}) +precompile(Tuple{typeof(Base.map), SolpropJulia.var"#adams_workspace##3#adams_workspace##4"{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}}) +precompile(Tuple{typeof(Base.map), StrideArraysCore.var"#12#13"{Tuple{Int64, Int64, Int64}}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base.map), StrideArraysCore.var"#12#13"{Tuple{Int64, Int64}}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.map), StrideArraysCore.var"#12#13"{Tuple{Int64}}, Tuple{Int64}}) +precompile(Tuple{typeof(Base.Math._hypot), Float64, Float64}) +precompile(Tuple{typeof(Base.Math.hypot), Float64, Float64}) +precompile(Tuple{typeof(Base.maximum), Function, Array{Base.Complex{Float64}, 1}}) +precompile(Tuple{typeof(Base.maybeview), Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(Base.maybeview), Array{Int64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, NamedTuple{(:spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :coarse_rate, :nc, :embedded), Tuple{Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Int64, Bool}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, NamedTuple{(:spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :coarse_rate, :nc), Tuple{Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Float64, 1}, Int64}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64}}, NamedTuple{(:crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:dims,), Tuple{Int64}}, Base.Pairs{Symbol, Float64, Nothing, NamedTuple{(:init,), Tuple{Float64}}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:dims,), Tuple{Int64}}, Base.Pairs{Symbol, Union{}, Nothing, NamedTuple{(), Tuple{}}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}}}, NamedTuple{(:weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing}}, NamedTuple{(:forward, :inverse), Tuple{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(), Tuple{}}, Base.Pairs{Symbol, Float64, Nothing, NamedTuple{(:init,), Tuple{Float64}}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(), Tuple{}}, Base.Pairs{Symbol, Real, Nothing, NamedTuple{(:dims, :init), Tuple{Int64, Float64}}}}) +precompile(Tuple{typeof(Base.mod), Int64, Type{Int64}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#flatten_tuples##0#flatten_tuples##1"{Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}, Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#flatten_tuples##0#flatten_tuples##1"{Tuple{Static.StaticInt{1}, Static.StaticInt{2}}, Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#flatten_tuples##0#flatten_tuples##1"{Tuple{Tuple{Static.StaticInt{1}}, Tuple{Static.StaticInt{1}}, Tuple{Static.StaticInt{1}}}, Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#flatten_tuples##0#flatten_tuples##1"{Tuple{Tuple{Static.StaticInt{1}}, Tuple{Static.StaticInt{1}}}, Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_index)}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_index)}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_shape)}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_shape)}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(StaticArrayInterface.is_splat_index)}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(StaticArrayInterface.is_splat_index)}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), Base.Fix{1, typeof(tuple), Int64}, Base.Val{1}}) +precompile(Tuple{typeof(Base.ntuple), Base.Iterators.var"#IteratorEltype##0#IteratorEltype##1"{Tuple{Array{PythonCall.Py, 1}, Array{Array{String, 1}, 1}}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), Base.Iterators.var"#IteratorSize##0#IteratorSize##1"{Tuple{Array{PythonCall.Py, 1}, Array{Array{String, 1}, 1}}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), Base.Iterators.var"#IteratorSize##2#IteratorSize##3"{Tuple{Array{Tuple{Int64, Int64}, 1}, Base.UnitRange{Int64}}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), Base.Iterators.var"#IteratorSize##2#IteratorSize##3"{Tuple{Base.UnitRange{Int64}, Base.UnitRange{Int64}}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), Base.Returns{Base.OneTo{Int64}}, Base.Val{1}}) +precompile(Tuple{typeof(Base.ntuple), Base.Returns{Base.OneTo{Int64}}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), Base.Returns{Bool}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Float64}, Int64}) +precompile(Tuple{typeof(Base.ntuple), PythonCall.JlWrap.Cjl.var"#11#12", Int64}) +precompile(Tuple{typeof(Base.ntuple), SolpropJulia.var"#adams_workspace##1#adams_workspace##2", Int64}) +precompile(Tuple{typeof(Base.ntuple), SolpropJulia.var"#block_view##0#block_view##1", Int64}) +precompile(Tuple{typeof(Base.ntuple), StaticArrayInterface.var"#_accum_dims##0#_accum_dims##1"{Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), StaticArrayInterface.var"#_accum_dims##0#_accum_dims##1"{Tuple{Int64, Int64}, Tuple{Int64, Int64}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), StaticArrayInterface.var"#map_indices_info##0#map_indices_info##1"{Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}}, Static.StaticInt{3}}) +precompile(Tuple{typeof(Base.ntuple), StaticArrayInterface.var"#map_indices_info##0#map_indices_info##1"{Tuple{Int64, Int64}, Tuple{Int64, Int64}}, Static.StaticInt{2}}) +precompile(Tuple{typeof(Base.Order.lt), Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}, Tuple{PythonCall.PyConvertPriority, Int64}, Tuple{PythonCall.PyConvertPriority, Int64}}) +precompile(Tuple{typeof(Base.pairs), NamedTuple{(:dims, :init), Tuple{Int64, Float64}}}) +precompile(Tuple{typeof(Base.pairs), NamedTuple{(:init,), Tuple{Float64}}}) +precompile(Tuple{typeof(Base.pointer), PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(Base.pointer), PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(Base.pointer), PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(Base._prechecked_iterate), Base.OneTo{Int64}, Int64}) +precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, PythonCall.Py}) +precompile(Tuple{typeof(Base.prod), Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.promote), Float64, Float64}) +precompile(Tuple{typeof(Base.reinterpret), Type{Int64}, Float64}) +precompile(Tuple{typeof(Base.reshape), Array{Base.Complex{Float64}, 2}, Int64, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(Base.setindex!), Array{Function, 1}, Function, Int64}) +precompile(Tuple{typeof(Base.setindex!), Array{PythonCall.Convert.PyConvertRule, 1}, PythonCall.Convert.PyConvertRule, Int64}) +precompile(Tuple{typeof(Base.setindex!), Array{Symbol, 1}, Symbol, Int64}) +precompile(Tuple{typeof(Base.setindex), Tuple{Int64, Int64, Int64}, Int64, Int64}) +precompile(Tuple{typeof(Base._setindex), Vararg{Int64, 5}}) +precompile(Tuple{typeof(Base.similar), Array{Base.Complex{Float64}, 2}}) +precompile(Tuple{typeof(Base.size), Array{Base.Complex{Float64}, 2}}) +precompile(Tuple{typeof(Base.size), Array{Base.Complex{Float64}, 3}, Int64}) +precompile(Tuple{typeof(Base.size), Array{Float64, 2}, Int64}) +precompile(Tuple{typeof(Base.sizeof), Symbol}) +precompile(Tuple{typeof(Base.structdiff), NamedTuple{(:dims, :init, :backend), Tuple{Int64, Float64, KernelAbstractions.POCL.POCLKernels.POCLBackend}}, Type{NamedTuple{(:backend, :workspace), T} where T<:Tuple}}) +precompile(Tuple{typeof(Base.structdiff), NamedTuple{(:dims, :init), Tuple{Int64, Float64}}, Type{NamedTuple{(:dims,), T} where T<:Tuple}}) +precompile(Tuple{typeof(Base.sum), Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.sum), Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{13, Symbol}}) # recompile +precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{17, Symbol}}) +precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{35, Symbol}}) +precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{44, Symbol}}) +precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{47, Symbol}}) +precompile(Tuple{typeof(Base.:(!=)), UInt32, UInt32}) +precompile(Tuple{typeof(Base.:(>)), UInt32, UInt32}) +precompile(Tuple{typeof(Base.:(<=)), UInt32, UInt8}) +precompile(Tuple{typeof(Base.:(>)), UInt8, UInt8}) +precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{LLVM.API.LLVMOpaqueModule}}, LLVM.Module}) +precompile(Tuple{typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{Base.Complex{Float64}}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{UInt8}, Int64}) +precompile(Tuple{typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{UInt8}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.:(var"==")), Base.OneTo{Int64}}) +precompile(Tuple{typeof(Base.:(var"==")), Int64}) +precompile(Tuple{typeof(Base.:(var"==")), JSON.JSONTypes.T, JSON.JSONTypes.T}) +precompile(Tuple{typeof(Base.:(var"==")), Method, Method}) +precompile(Tuple{typeof(Base.:(var"==")), Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base.:(var"==")), TypeVar, TypeVar}) +precompile(Tuple{typeof(Base.vcat), Array{Bool, 1}, Bool}) +precompile(Tuple{typeof(Base.vcat), Array{Float64, 1}, Float64}) +precompile(Tuple{typeof(Base.vcat), Array{Int64, 1}, Int64}) +precompile(Tuple{typeof(Base.zero), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.zeros), Int64}) +precompile(Tuple{typeof(Base.zeros), Int64, Int64}) +precompile(Tuple{typeof(Base.zeros), Type{Float64}, Int64, Int64}) +precompile(Tuple{typeof(BitTwiddlingConvenienceFunctions.nextpow2), Int64}) +precompile(Tuple{typeof(CompilerCaching.get_codeinfos), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Core.CodeInstance}) +precompile(Tuple{typeof(CompilerCaching.with_fresh_inference_cache), CompilerCaching.var"#infer_source!##0#infer_source!##1"{Core.MethodInstance}, GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}}) +precompile(Tuple{typeof(Core.checked_dims), Int64, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(Core._checked_mul_dims), Int64, Int64, Int64}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:by, :rev), Tuple{PythonCall.Convert.var"#_pyconvert_get_rules##19#_pyconvert_get_rules##20", Bool}}, typeof(Base.sort), Base.OneTo{Int64}}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:compiled,), Tuple{Base.Dict{Any, Any}}}, typeof(GPUCompiler.check_ir), GPUCompiler.CompilerJob{GPUCompiler.SPIRVCompilerTarget, KernelAbstractions.POCL.OpenCLCompilerParams}, LLVM.Module, GPUCompiler.Relocations}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:flags, :num_threads), Tuple{UInt32, Int64}}, typeof(AbstractFFTs.plan_brfft), Array{Base.Complex{Float64}, 2}, Int64, Int64}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:interp,), Tuple{GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}}}, typeof(GPUCompiler.typeinf_type), Core.MethodInstance}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:modes, :nodes, :synthesis), Tuple{Int64, Int64, Array{Float64, 2}}}, typeof(SolpropJulia.raman_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}, Int64, Int64}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:name,), Tuple{Nothing}}, typeof(KernelAbstractions.POCL.compiler_config), KernelAbstractions.POCL.nanoOpenCL.Device}) # recompile +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:threads, :batch), Tuple{Int64, Int64}}, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Function, Array{Base.Complex{Float64}, 3}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:threads,), Tuple{Int64}}, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Function, Array{Base.Complex{Float64}, 2}, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:threads,), Tuple{Int64}}, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Function, Array{Float64, 2}, Int64}) +precompile(Tuple{typeof(FFTW.fftw_init_check)}) +precompile(Tuple{typeof(FFTW.maybe_destroy_plan), FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}) +precompile(Tuple{typeof(FFTW.maybe_destroy_plan), FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}) +precompile(Tuple{typeof(FFTW.maybe_destroy_plan), FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}) +precompile(Tuple{typeof(FFTW.maybe_destroy_plan), FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}) +precompile(Tuple{typeof(GPUCompiler.build_runtime), GPUCompiler.CompilerJob{T, P} where P where T, GPUCompiler.CompilerConfig{GPUCompiler.SPIRVCompilerTarget, KernelAbstractions.POCL.OpenCLCompilerParams}}) +precompile(Tuple{typeof(GPUCompiler.compile), Symbol, GPUCompiler.CompilerJob{T, P} where P where T}) +precompile(Tuple{typeof(GPUCompiler.drive_inference!), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Core.MethodInstance}) +precompile(Tuple{typeof(GPUCompiler.finish_ir!), GPUCompiler.CompilerJob{GPUCompiler.SPIRVCompilerTarget, KernelAbstractions.POCL.OpenCLCompilerParams}, LLVM.Module, LLVM.Function}) +precompile(Tuple{typeof(GPUCompiler.llvm_datalayout), GPUCompiler.SPIRVCompilerTarget}) +precompile(Tuple{typeof(GPUCompiler.mcgen), GPUCompiler.CompilerJob{GPUCompiler.SPIRVCompilerTarget, KernelAbstractions.POCL.OpenCLCompilerParams}, LLVM.Module, LLVM.API.LLVMCodeGenFileType}) +precompile(Tuple{typeof(GPUCompiler.stack_method_tables), UInt64, Core.MethodTable}) +precompile(Tuple{typeof(JLLWrappers.get_julia_libpaths)}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type{Base.Complex{Float64}}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type{Base.Complex{Float64}}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type{Float64}, Tuple{Int64}}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type{Float64}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type, Int64, Int64}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type, Int64, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(LLVM.api_cstring_arg), Any}) +precompile(Tuple{typeof(LLVM.check_library), LLVM.Library, LLVM.LLVMSymbol}) +precompile(Tuple{typeof(LLVM.check_library), LLVM.Library, LLVM.Module, String}) +precompile(Tuple{typeof(LLVM.getprop), LLVM.Function, Base.Val{:name}}) +precompile(Tuple{typeof(LLVM.getprop), LLVM.Function, Base.Val{:uses}}) +precompile(Tuple{typeof(pocl_standalone_jll.is_available)}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Base.Complex{Float64}, 2}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Base.Complex{Float64}, 3}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Float64, 1}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Float64, 2}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Int32, 2}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Tuple{Float64, Float64}, 1}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Tuple{Float64, Float64, Float64}, 1}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Base.ReshapedArray{Float64, 2, Base.ReinterpretArray{Float64, 2, Base.Complex{Float64}, Array{Base.Complex{Float64}, 2}, false}, Tuple{}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Base.ReshapedArray{Float64, 2, Base.ReinterpretArray{Float64, 2, Base.Complex{Float64}, Base.SubArray{Base.Complex{Float64}, 2, Array{Base.Complex{Float64}, 2}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.UnitRange{Int64}}, true}, false}, Tuple{}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Base.SubArray{Float64, 2, Array{Float64, 2}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.UnitRange{Int64}}, true}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Base.SubArray{Float64, 2, Array{Float64, 2}, Tuple{Base.UnitRange{Int64}, Base.Slice{Base.OneTo{Int64}}}, false}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Bool}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Float64}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Int64}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Polyester.CombineIndices}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Polyester.NoLoop}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#absorber!##0#absorber!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#add_plasma_spectra!##0#add_plasma_spectra!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Int64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Float64, 2}, Array{Float64, 1}, Int64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#analytic_signal!##2#analytic_signal!##3"{Array{Base.Complex{Float64}, 2}, Float64, Int64, Float64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#band_alarm##0#band_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#bind_monitor!##0#bind_monitor!##1"{Array{Int32, 2}, Array{UInt8, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#collar_factor##0#collar_factor##1"{Array{Float64, 1}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#column_energy##0#column_energy##1"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##0#edge_energy##1"{Float64, Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##2#edge_energy##3"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#columns_into!##0#columns_into!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#combine!##4#combine!##5"{Int64, Tuple{Float64, Float64, Float64}, NTuple{7, Float64}, NTuple{7, Float64}, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#convolve!##0#convolve!##1"{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#finish_band!##0#finish_band!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#finish_source!##0#finish_source!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#free_propagators!##0#free_propagators!##1"{Float64, Bool, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#gather_columns!##0#gather_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Int64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#integrate_samples!##0#integrate_samples!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Float64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#mask!##0#mask!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#material_stage!##0#material_stage!##1"{Int64, Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_envelope!##0#nonlinear_envelope!##1"{Array{Float64, 2}, Bool, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Float64, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#path_propagators!##0#path_propagators!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#plasma_columns!##0#plasma_columns!##1"{Array{Float64, 2}, Int64, Float64, Float64, Float64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#plasma_samples!##0#plasma_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#plasma_samples!##2#plasma_samples!##3"{Array{Float64, 2}, Float64, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#plasma_samples!##4#plasma_samples!##5"{Array{Float64, 2}, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Base.SubArray{Base.Complex{Float64}, 2, Array{Base.Complex{Float64}, 3}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.Slice{Base.OneTo{Int64}}, Int64}, true}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#population_columns!##0#population_columns!##1"{Array{Float64, 2}, Int64, Float64, Int64, Int64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#population_samples!##0#population_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#population_samples!##2#population_samples!##3"{Float64, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#population_samples!##4#population_samples!##5"{Array{Float64, 2}, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#population_samples!##6#population_samples!##7"{Float64, Float64, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#poynting!##0#poynting!##1"{Base.Complex{Float64}, Float64, Float64, Int64, Bool, Array{Float64, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#poynting!##2#poynting!##3"{Float64, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#poynting!##4#poynting!##5"{Float64, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#propagators!##2#propagators!##3"{NTuple{7, Float64}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#quadrature_alarm##0#quadrature_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Int64, Bool, Array{Float64, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Float64, 2}, Int64, Bool, Array{Float64, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#raman_products!##0#raman_products!##1"{Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#rk4!##0#rk4!##1"{Float64, Float64, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#rk4!##2#rk4!##3"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#rk4!##4#rk4!##5"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#rk4!##6#rk4!##7"{Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#scatter!##0#scatter!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#scatter_columns!##0#scatter_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64, Array{Int64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##8#source_free!##9"{Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##0#source_spectral!##1"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##10#source_spectral!##11"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##2#source_spectral!##3"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##4#source_spectral!##5"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##6#source_spectral!##7"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##8#source_spectral!##9"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#spatial_local!##0#spatial_local!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#spatial_local!##2#spatial_local!##3"{Base.Complex{Float64}, Float64, Int64, Bool, Int64, Int64, Int64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#spatial_local!##4#spatial_local!##5"{Float64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#spectral_plasma!##2#spectral_plasma!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#split_free!##2#split_free!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#trial!##2#trial!##3"{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, NTuple{6, Float64}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#trial!##4#trial!##5"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#weighted_norm##0#weighted_norm##1"{Array{Base.Complex{Float64}, 2}, Float64, Float64, Float64, Array{Bool, 1}, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Static.StaticInt{1}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Tuple{Float64, Float64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Tuple{Float64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{typeof(Base.:(+))}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{typeof(SolpropJulia.transform_block!)}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.combine), Polyester.CombineIndices, Polyester.NoLoop, Int64}) +precompile(Tuple{typeof(PythonCall.Convert.pyconvert_isunconverted), PythonCall.Convert.Unconverted}) +precompile(Tuple{typeof(PythonCall.Convert.pyconvert_result), Type{Any}, Int64}) +precompile(Tuple{typeof(PythonCall.Core.pycallargs), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.Core.pytuple_fromiter), Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.JlWrap.Cjl._pyjl_get_buffer_impl), Ptr{PythonCall.C.PyObject}, Ptr{PythonCall.C.Py_buffer}, Int32, Array{Bool, 1}, typeof(PythonCall.JlWrap.pyjlarray_buffer_info)}) +precompile(Tuple{typeof(PythonCall.JlWrap.Cjl._pyjl_get_buffer_impl), Ptr{PythonCall.C.PyObject}, Ptr{PythonCall.C.Py_buffer}, Int32, Array{Float64, 1}, typeof(PythonCall.JlWrap.pyjlarray_buffer_info)}) +precompile(Tuple{typeof(PythonCall.JlWrap.Cjl._pyjl_get_buffer_impl), Ptr{PythonCall.C.PyObject}, Ptr{PythonCall.C.Py_buffer}, Int32, Array{Float64, 2}, typeof(PythonCall.JlWrap.pyjlarray_buffer_info)}) +precompile(Tuple{typeof(PythonCall.JlWrap.Cjl._pyjl_get_buffer_impl), Ptr{PythonCall.C.PyObject}, Ptr{PythonCall.C.Py_buffer}, Int32, Array{Int64, 1}, typeof(PythonCall.JlWrap.pyjlarray_buffer_info)}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), Main.var"#2#3", PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call_nogil), typeof(SolpropJulia.commit!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call_nogil), typeof(SolpropJulia.march_run!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call_nogil), typeof(SolpropJulia.rk4!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call_nogil), typeof(SolpropJulia.trial!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_edge!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_monitor!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_poynting!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_spatial!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_stage_constants!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_stage_table!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.clenshaw_points!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.column_energy), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.configure_march!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.configure_stages_at!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.copy_state!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.create), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.device_name), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.loaded_digest), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.load!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.march_run!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.node_energy), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.occupancy), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.population_snapshot), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.poynting!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.rebind_weight!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.record_digest), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.reset_work!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.runtime), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.spatial_local!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.split_power), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.state_power), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), Module, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:zs, :counts, :history_z, :history_predicted, :history_row, :ledger, :rows, :orders, :reason, :cost, :floor_proposal, :stage, :category, :message, :alarm, :alarm_z, :first_alarm, :split_powers, :split_steps), Tuple{Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Float64, Int64, Int64, String, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlmodule_seval), Module, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlmodule_seval), Module, PythonCall.Py}) # recompile +precompile(Tuple{typeof(PythonCall.pyconvert_return), Bool}) +precompile(Tuple{typeof(PythonCall.pyis), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.Utils.size_to_fstrides), Int64, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Utils.size_to_fstrides), Int64, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_size), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{1}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_size), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{2}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_size), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{3}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{1}, Type{Base.Complex{Float64}}, Tuple{Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{1}, Type{Bool}, Tuple{Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{1}, Type{Float64}, Tuple{Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{1}, Type{Int64}, Tuple{Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{2}, Type{Base.Complex{Float64}}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{2}, Type{Float64}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{2}, Type{UInt8}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{3}, Type{Base.Complex{Float64}}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{3}, Type{Float64}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(REPLExt.__init__)}) # recompile +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.approach), SolpropJulia.Policy, Float64, NamedTuple{(:dz, :target, :landed, :at), Tuple{Float64, Int64, Bool, Float64}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_spatial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}, Nothing, Int64}) +precompile(Tuple{typeof(SolpropJulia.bind_spatial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}, Nothing, Int64}) +precompile(Tuple{typeof(SolpropJulia.bind_spatial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, Int64}) +precompile(Tuple{typeof(SolpropJulia.bind_spatial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, Int64}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_constants!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Vararg{Float64, 4}}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_constants!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Vararg{Float64, 4}}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_table!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, String, PythonCall.PyArray{Float64, 1, false, true, Float64}, Float64, Float64, PythonCall.PyArray{Float64, 3, false, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_table!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, String, PythonCall.PyArray{Float64, 1, false, true, Float64}, Float64, Float64, PythonCall.PyArray{Float64, 3, false, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_table!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, String, PythonCall.PyArray{Float64, 1, false, true, Float64}, Float64, Float64, PythonCall.PyArray{Float64, 3, false, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_table!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, String, PythonCall.PyArray{Float64, 1, false, true, Float64}, Float64, Float64, PythonCall.PyArray{Float64, 3, false, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.clenshaw_points!), PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, false, true, Float64}, Float64, Float64, PythonCall.PyArray{Float64, 3, false, false, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.colsum!), SolpropJulia.var"#edge_energy##0#edge_energy##1"{Float64, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Array{Float64, 1}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.colsum!), SolpropJulia.var"#edge_energy##2#edge_energy##3"{Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Array{Float64, 1}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, false, true, Float64}, PythonCall.PyArray{Float64, 3, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, false, true, Float64}, PythonCall.PyArray{Float64, 3, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_stages_at!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, PythonCall.PyArray{Float64, 1, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_stages_at!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, PythonCall.PyArray{Float64, 1, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.copy_between!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}}) +precompile(Tuple{typeof(SolpropJulia.copy_between!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.create_free), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}}) +precompile(Tuple{typeof(SolpropJulia.create_modal), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}}) +precompile(Tuple{typeof(SolpropJulia.create), PythonCall.PyDict{Any, Any}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.dzeros), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Type, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(SolpropJulia.dzeros), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Type, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(SolpropJulia.each_column!), SolpropJulia.var"#spatial_local!##4#spatial_local!##5"{Float64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.each_column!), SolpropJulia.var"#spatial_local!##4#spatial_local!##5"{Float64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#bind_monitor!##0#bind_monitor!##1"{Array{Int32, 2}, Array{UInt8, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#bind_monitor!##0#bind_monitor!##1"{Array{Int32, 2}, Array{UInt8, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#poynting!##0#poynting!##1"{Base.Complex{Float64}, Float64, Float64, Int64, Bool, Array{Float64, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#poynting!##2#poynting!##3"{Float64, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#poynting!##4#poynting!##5"{Float64, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#spatial_local!##0#spatial_local!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#spatial_local!##0#spatial_local!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#spatial_local!##2#spatial_local!##3"{Base.Complex{Float64}, Float64, Int64, Bool, Int64, Int64, Int64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#spatial_local!##2#spatial_local!##3"{Base.Complex{Float64}, Float64, Int64, Bool, Int64, Int64, Int64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.factor), SolpropJulia.Policy, Float64, Int64, Float64}) +precompile(Tuple{typeof(SolpropJulia.fir_interior!), Array{Float64, 2}, Array{Float64, 2}, Int64, Int64, Int64, NTuple{5, Float64}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.landing), SolpropJulia.Policy, Float64, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.monitor_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.monitor_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.node_spectra!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.node_spectra!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.node_spectra!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.node_spectra!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.path_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}}) +precompile(Tuple{typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Function, Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Function, Array{Base.Complex{Float64}, 2}, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Function, Array{Float64, 2}, Int64}) +precompile(Tuple{typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Function, Array{Base.Complex{Float64}, 2}, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Function, Array{Float64, 2}, Int64}) +precompile(Tuple{typeof(SolpropJulia.plasma_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}, Vararg{Int64, 4}}) +precompile(Tuple{typeof(SolpropJulia.plasma_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}, Vararg{Int64, 4}}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.proposal), SolpropJulia.Policy, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.py_min), Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.quiet_capped), SolpropJulia.Policy, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.reached), Float64, Float64, Int64}) +precompile(Tuple{typeof(SolpropJulia.record_digest), String}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.spatial_local!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.spatial_local!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.spatial_local!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.spatial_local!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.stage_values), NamedTuple{(:edges, :lower, :upper, :c), Tuple{Array{Float64, 1}, Float64, Float64, Array{Float64, 3}}}, Array{Float64, 1}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.stencil), SolpropJulia.Policy, Float64, Float64, Array{Float64, 1}, Array{Int64, 1}, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.upload), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, Array{Base.Complex{Float64}, 1}}) +precompile(Tuple{typeof(SolpropJulia.upload), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, Array{Base.Complex{Float64}, 2}}) +precompile(Tuple{typeof(SolpropJulia.upload), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, Array{Bool, 1}}) +precompile(Tuple{typeof(SolpropJulia.upload), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, Array{Float64, 1}}) +precompile(Tuple{typeof(SolpropJulia.upload), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, Array{Float64, 2}}) +precompile(Tuple{typeof(SolpropJulia.vexp), Float64}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(StaticArrayInterface._accum_dims), Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(StaticArrayInterface._accum_dims), Tuple{Int64, Int64}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(StaticArrayInterface._find_first_true), Tuple{Bool, Bool}}) +precompile(Tuple{typeof(StaticArrayInterface._find_first_true), Tuple{Bool, Bool, Bool}}) +precompile(Tuple{typeof(StaticArrayInterface.known_offsets), Type{StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}, Int64}) +precompile(Tuple{typeof(StaticArrayInterface.known_offsets), Type{StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64}}}, Int64}) +precompile(Tuple{typeof(StaticArrayInterface.known_offsets), Type{StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}, Int64}) +precompile(Tuple{typeof(StaticArrayInterface.rank_to_sortperm), Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}) +precompile(Tuple{typeof(StaticArrayInterface.rank_to_sortperm), Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}) +precompile(Tuple{typeof(StaticArrayInterface.static_length), Base.OneTo{Int64}}) +precompile(Tuple{typeof(Static.eachop), typeof(Static._get_known), Tuple{Static.StaticInt{1}}, Type}) +precompile(Tuple{typeof(Static.known), Type{var"#s22"} where var"#s22"<:Tuple}) +precompile(Tuple{typeof(Static._return_int), Int64}) +precompile(Tuple{typeof(Static.static), Bool}) +precompile(Tuple{typeof(Static.static), Int64}) +precompile(Tuple{Type{Pair{Any, Tuple{Bool, Bool}}}, Any, Any}) # recompile +precompile(Tuple{Type{Pair{Int64, Int64}}, Any, Any}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##2#rk4!##3"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##4#rk4!##5"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##6#rk4!##7"{Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#weighted_norm##0#weighted_norm##1"{Array{Base.Complex{Float64}, 2}, Float64, Float64, Float64, Array{Bool, 1}, Array{Float64, 1}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#combine!##4#combine!##5"{Int64, Tuple{Float64, Float64, Float64}, NTuple{7, Float64}, NTuple{7, Float64}, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#band_alarm##0#band_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#quadrature_alarm##0#quadrature_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 3, (1, 2, 3), Tuple{Int64, Int64, Int64}, Tuple{Nothing, Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 3, (1, 2, 3), Tuple{Int64, Int64, Int64}, Tuple{Nothing, Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#column_energy##0#column_energy##1"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##0#edge_energy##1"{Float64, Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##2#edge_energy##3"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#plasma_columns!##0#plasma_columns!##1"{Array{Float64, 2}, Int64, Float64, Float64, Float64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#population_columns!##0#population_columns!##1"{Array{Float64, 2}, Int64, Float64, Int64, Int64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#spatial_local!##4#spatial_local!##5"{Float64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#absorber!##0#absorber!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#add_plasma_spectra!##0#add_plasma_spectra!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##2#analytic_signal!##3"{Array{Base.Complex{Float64}, 2}, Float64, Int64, Float64, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#bind_monitor!##0#bind_monitor!##1"{Array{Int32, 2}, Array{UInt8, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#collar_factor##0#collar_factor##1"{Array{Float64, 1}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#columns_into!##0#columns_into!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#convolve!##0#convolve!##1"{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#finish_band!##0#finish_band!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#finish_source!##0#finish_source!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_propagators!##0#free_propagators!##1"{Float64, Bool, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#gather_columns!##0#gather_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Int64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#integrate_samples!##0#integrate_samples!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Float64, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#mask!##0#mask!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#material_stage!##0#material_stage!##1"{Int64, Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_envelope!##0#nonlinear_envelope!##1"{Array{Float64, 2}, Bool, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Float64, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#path_propagators!##0#path_propagators!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##0#plasma_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##2#plasma_samples!##3"{Array{Float64, 2}, Float64, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##4#plasma_samples!##5"{Array{Float64, 2}, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Base.SubArray{Base.Complex{Float64}, 2, Array{Base.Complex{Float64}, 3}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.Slice{Base.OneTo{Int64}}, Int64}, true}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##0#population_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##2#population_samples!##3"{Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##4#population_samples!##5"{Array{Float64, 2}, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##6#population_samples!##7"{Float64, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##0#poynting!##1"{Base.Complex{Float64}, Float64, Float64, Int64, Bool, Array{Float64, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##2#poynting!##3"{Float64, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##4#poynting!##5"{Float64, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#propagators!##2#propagators!##3"{NTuple{7, Float64}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Int64, Bool, Array{Float64, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Float64, 2}, Int64, Bool, Array{Float64, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_products!##0#raman_products!##1"{Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#rk4!##0#rk4!##1"{Float64, Float64, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#scatter!##0#scatter!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#scatter_columns!##0#scatter_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64, Array{Int64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##8#source_free!##9"{Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##0#source_spectral!##1"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##10#source_spectral!##11"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##2#source_spectral!##3"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##4#source_spectral!##5"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##6#source_spectral!##7"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##8#source_spectral!##9"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spatial_local!##0#spatial_local!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spatial_local!##2#spatial_local!##3"{Base.Complex{Float64}, Float64, Int64, Bool, Int64, Int64, Int64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spectral_plasma!##2#spectral_plasma!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##2#split_free!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#trial!##2#trial!##3"{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, NTuple{6, Float64}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#trial!##4#trial!##5"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Int64, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#occupancy##0#occupancy##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Int32, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Int32}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#rowsum!##0#rowsum!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}, SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Int64, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#rowsum!##0#rowsum!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}, SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Float64, 2}, Array{Float64, 1}, Int64, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#transform_all!##0#transform_all!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, typeof(SolpropJulia.transform_block!), SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Tuple{StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}, Tuple{StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{PolyesterWeave.UnsignedIteratorEarlyStop{U} where U}, UInt64, UInt32}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, 1, true, true, Base.Complex{Float64}}}, Base.Val{:new}, Ptr{Base.Complex{Float64}}, Tuple{Int64}, Tuple{Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}, Base.Val{:new}, Ptr{Base.Complex{Float64}}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}}, Base.Val{:new}, Ptr{Base.Complex{Float64}}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}, Base.Val{:new}, Ptr{Base.Complex{Float64}}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, 3, true, false, Base.Complex{Float64}}}, Base.Val{:new}, Ptr{Base.Complex{Float64}}, Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, N, M, L, R} where R where L where M where N}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, N, M, L, R} where R where L where M where N}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{Type{PythonCall.PyArray{Bool, 1, true, true, Bool}}, Base.Val{:new}, Ptr{Bool}, Tuple{Int64}, Tuple{Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.Py}, Array{Float64, 1}}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 1, false, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64}, Tuple{Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 1, true, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64}, Tuple{Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 2, false, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 2, true, false, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 2, true, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 3, false, false, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 3, false, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 3, true, false, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 3, true, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Int64, 1, true, true, Int64}}, Base.Val{:new}, Ptr{Int64}, Tuple{Int64}, Tuple{Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{UInt8, 2, true, true, UInt8}}, Base.Val{:new}, Ptr{UInt8}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{UInt8, N, M, L, R} where R where L where M where N}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{Type{PythonCall.Py}, Float64}) +precompile(Tuple{Type{PythonCall.Py}, Function}) +precompile(Tuple{Type{PythonCall.Py}, Int64}) +precompile(Tuple{Type{PythonCall.Py}, Module}) +precompile(Tuple{Type{PythonCall.Py}, Nothing}) +precompile(Tuple{Type{PythonCall.Py}, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.Py}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}) +precompile(Tuple{Type{PythonCall.Py}, Tuple{Array{Float64, 2}, Array{Float64, 1}}}) +precompile(Tuple{Type{PythonCall.Py}, Tuple{Float64, Float64}}) +precompile(Tuple{Type{PythonCall.Py}, Tuple{UInt64, UInt64}}) +precompile(Tuple{Type{SolpropJulia.Blocked{P} where P}, Array{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, 1}, Array{Base.UnitRange{Int64}, 1}, Int64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{Static.StaticInt{N} where N}, Int64}) +precompile(Tuple{Type{Tuple}, Tuple{Int64, Int64}}) +precompile(Tuple{Type{UInt128}, UInt64}) +precompile(Tuple{UnsafePointers.var"##19#20", Vararg{Any, 5}}) +precompile(Tuple{UnsafePointers.var"##21#22", Vararg{Any, 5}}) +precompile(Tuple{UnsafePointers.var"##23#24", Vararg{Any, 5}}) diff --git a/julia/src/responses.jl b/julia/src/responses.jl new file mode 100644 index 000000000..6e845d4c0 --- /dev/null +++ b/julia/src/responses.jl @@ -0,0 +1,754 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# The translated scalar responses: Kerr, one field-plasma channel and one Raman term. +# Rate tables, constants, FIR taps and collar derivatives all come from the seam. + +@inline polarization(value::Real, factor, analytic_factor) = factor * (value * value) * value +@inline polarization(value::Complex, factor, analytic_factor) = + factor * analytic_factor * abs2(value) * real(value) + +"""Write the Kerr and Raman polarisation of each node's field over it, windowed. + +`values` is what the Kerr term reads: the field, or its analytic signal. Raman, when +present, multiplies the field by its convolved drive (`raman_drive!`). +""" +function nonlinear_nodes!(nodes, values, c, factor, raman, count) + window, a = c.window, c.analytic_factor + T = eltype(window) + g = stage_scalar(c, 1, factor) + if raman === nothing + each!(c, size(nodes, 1), count) do t, m + @inbounds nodes[t, m] = polarization(values[t, m], stage_value(g), a) * window[t] + end + else + drive, r = raman.products ? raman.nodal : raman.drive, T(raman.factor) + each!(c, size(nodes, 1), count) do t, m + @inbounds begin + v = nodes[t, m] + nodes[t, m] = muladd(r * v, drive[t, m], polarization(values[t, m], stage_value(g), a)) * window[t] + end + end + end +end + +function nonlinear_envelope!(nodes, c, factor, raman, count) + window = c.window + T = eltype(window) + g = stage_scalar(c, 1, factor, c.analytic_factor) + r = raman === nothing ? zero(T) : T(raman.factor) + drive = raman === nothing ? nodes : raman.drive + live = raman !== nothing + # The third harmonic's term, factor h exp(2 i w0 t) E^2 E, where one is compiled. + hg, carrier = stage_scalar(c, 1, factor, c.harmonic), c.carrier + harmonic = !iszero(c.harmonic) + each!(c, size(nodes, 1), count) do t, m + @inbounds begin + v = nodes[t, m] + response = stage_value(g) * abs2(v) * v + if harmonic + response += stage_value(hg) * carrier[t] * (v * v) * v + end + if live + response = muladd(r * v, real(drive[t, m]), response) + end + nodes[t, m] = response * window[t] + end + end +end + +"""Replace `analytic` by the analytic signal of the real columns of `nodes`.""" +function analytic_signal!(analytic, nodes, forward, inverse, c, count) + nt, chunk = size(analytic) + each!(c, nt, chunk) do t, m + @inbounds analytic[t, m] = m <= count ? nodes[t, m] : 0 + end + forward * analytic + # The unnormalised inverse's 1/nt is folded into the one-sided spectral factor. + T = real(eltype(analytic)) + one, two, half, none = inv(T(nt)), 2 / T(nt), nt ÷ 2, zero(T) + each!(c, nt, chunk) do f, m + @inbounds analytic[f, m] *= (f == 1 || f == half + 1) ? one : f <= half ? two : none + end + inverse * analytic + nothing +end + +# --- plasma ------------------------------------------------------------------------- + +function plasma_workspace(c, host, nt, chunk, nm, nn) + host.flag("envelope_plasma") && return envelope_plasma_workspace(c, host, nt, chunk, nm, nn) + host.flag("plasma") || return nothing + T = c.T + # Columns: the chunk's where the streams are transformed node by node (free space, + # the spectral modal path), the modes' where they are projected first. + by_node = c.free || (haskey(c, :spectral) && c.spectral) + columns = by_node ? 0 : nm + # Several channels (a mixture's species): each its rate table and constants, the + # first's also as the workspace's own fields, so that one channel runs as before. + count = host.has("plasma_count") ? host.int("plasma_count") : 1 + suffix(k) = k == 1 ? "" : "_$k" + channels = [(coefficients=upload(c, host.array("plasma_coefficients" * suffix(k), T)), + parameters=host.array("plasma_parameters" * suffix(k), Float64)) for k in 1:count] + fractions_all, peaks_all = dzeros(c, T, nn, count), dzeros(c, T, nn, count) + ( + channels=channels, fractions_all=fractions_all, peaks_all=peaks_all, channel=1, + coefficients=channels[1].coefficients, + # Field range, rate cap, log-table origin and step, charge-mass ratio and + # ionisation potential; density and preionisation are a stage's (stages.jl). + parameters=channels[1].parameters, + taps=upload(c, host.array("plasma_taps", T)), floor=host.flag("plasma_floor"), + dt=T(host.real("dt")), field_scale=T(c.scale), + inverse_omega=upload(c, T.(inv.(host.array("omega", Float64)))), + derivative=upload(c, host.array("window_derivative", T)), + rate=dzeros(c, T, nt, chunk), fraction=dzeros(c, T, nt, chunk), + # A CPU column's live samples, by index, and their fields (`exposure_column!`). + live=zeros(Int32, oncpu(c) ? nt : 0, oncpu(c) ? chunk : 0), + scratch=zeros(T, oncpu(c) ? nt : 0, oncpu(c) ? chunk : 0), + knots=zeros(Int32, oncpu(c) ? nt : 0, oncpu(c) ? chunk : 0), + integrand=dzeros(c, T, nt, chunk), current=dzeros(c, T, nt, chunk), + gated=dzeros(c, T, nt, chunk), edge=dzeros(c, T, nt, chunk), + projected=dzeros(c, T, nt, columns), edge_projected=dzeros(c, T, nt, columns), + coarse=dzeros(c, T, nt, columns), coarse_edge=dzeros(c, T, nt, columns), + spectrum=dzeros(c, Complex{T}, nt ÷ 2 + 1, by_node ? chunk : nm), + edge_spectrum=dzeros(c, Complex{T}, nt ÷ 2 + 1, by_node ? chunk : nm), + fractions=view(fractions_all, :, 1), peaks=view(peaks_all, :, 1), + parts=dzeros(c, T, 6, chunk), + ) +end + +"""The piecewise-cubic ionisation rate in log |E|, clamped to the table's range.""" +@inline function rate_value(value, table, lower, upper, cap, origin, step) + x = abs(value) + x < lower && return zero(cap) + x >= upper && return cap + table_rate(x, table, cap, origin, step) +end +# The vectorised passes are functions of their own: inside a column's closure the +# loops stayed scalar. The table's lookup is a pass between them, since a gather keeps +# LLVM from vectorising a loop: argon's live rates 39 ns a sample -> 10 ns. +@noinline function live_rates!(scratch, knots, node, count, table, cap, origin, step) + last = Int32(size(table, 2)) + # The logarithm, then each sample's knot and its distance past it, vectorised; only + # the table's four loads and the cubic stay scalar (`log_rate`'s cubic, contracted + # the same way, so the two paths agree). + @inbounds @simd for i in 1:count + logarithm = vlog(scratch[i, node]) + j = clamp(unsafe_trunc(Int32, floor((logarithm - origin) / step)) + Int32(1), + Int32(1), last) + knots[i, node] = j + scratch[i, node] = logarithm - (origin + (j - 1) * step) + end + @inbounds for i in 1:count + j, s = knots[i, node], scratch[i, node] + scratch[i, node] = cubic(table, j, s) + end + @inbounds @simd for i in 1:count + scratch[i, node] = min(vexp(scratch[i, node]), cap) + end +end +"""Every sample's fraction and the free current's integrand, vectorised (`vexp`). + +Before the column's support the exposure is exactly zero, and past it exactly its +last value: each run takes the one fraction its exposure gives, formed once, so only +the samples between take an exponential each (the values are the same bit for bit). +""" +@noinline function fraction_column!(fraction, integrand, nodes, node, initial, charge, floor) + none = zero(initial) + nt = size(nodes, 1) + fraction_of(exposure) = 1 - (1 - initial) * vexp(-(floor ? max(exposure, none) : exposure)) + head = 0 + @inbounds while head < nt && iszero(fraction[head+1, node]) + head += 1 + end + tail = nt + 1 + @inbounds last = fraction[nt, node] + @inbounds while tail > head + 1 && fraction[tail-1, node] === last + tail -= 1 + end + before, after = fraction_of(none), fraction_of(last) + @inbounds @simd for t in 1:head + fraction[t, node] = before + integrand[t, node] = before * charge * nodes[t, node] + end + @inbounds @simd for t in head+1:tail-1 + value = fraction_of(fraction[t, node]) + fraction[t, node] = value + integrand[t, node] = value * charge * nodes[t, node] + end + @inbounds @simd for t in tail:nt + fraction[t, node] = after + integrand[t, node] = after * charge * nodes[t, node] + end +end +"""The gated and edge currents of a column: the free current plus the loss current, +formed everywhere and kept where the rate and the field are live.""" +@noinline function currents_column!(gated, edge, nodes, rate, fraction, current, window, + derivative, node, potential, density, add=false) + none = zero(potential) + @inbounds @simd for t in axes(nodes, 1) + field, value = nodes[t, node], rate[t, node] + squared = field * field + loss = ifelse((value > 0) & (squared > 0), + (potential * value * (1 - fraction[t, node]) / squared) * field, none) + total = density * (current[t, node] + loss) + if add + gated[t, node] += window[t] * total + edge[t, node] += derivative[t] * total + else + gated[t, node] = window[t] * total + edge[t, node] = derivative[t] * total + end + end +end +"""The rate inside the table's span, `lower <= x < upper` (or NaN).""" +@inline table_rate(x, table, cap, origin, step) = + min(exp(log_rate(log(x), table, origin, step)), cap) +"""The table's `log W` at `log |E|`: the knot's cubic in the distance past it.""" +@inline function log_rate(logarithm, table, origin, step) + j = clamp(unsafe_trunc(Int, floor((logarithm - origin) / step)) + 1, 1, size(table, 2)) + s = logarithm - (origin + (j - 1) * step) + cubic(table, j, s) +end +"""Knot `j`'s cubic at `s` by Horner's rule, contracted (SEP 25 permits fused +multiply-adds in an ordinary kernel).""" +@inline cubic(table, j, s) = + @inbounds muladd(muladd(muladd(table[1, j], s, table[2, j]), s, table[3, j]), s, table[4, j]) +@inline rate_arguments(p) = + (p.field_scale, p.coefficients, ntuple(k -> typeof(p.dt)(p.parameters[k]), 5)...) +"""The rate at a scaled field's physical value `s E`: exact, s a power of two.""" +@inline scaled_rate(value, scale, args...) = rate_value(scale * value, args...) + +# A symmetric FIR, reflected at the ends as RunningIntegral is, then a running +# trapezoid. The scan runs in order on a CPU; that is a choice, not policy: SEP 25 (5, +# item 5) permits a reassociated or segmented scan within its prefix's rounding bound, +# as the GPU's column scans are. The sums contract. +@inline function filtered(values, t, node, taps) + nt = size(values, 1) + @inbounds value = taps[1] * values[t, node] + @inbounds for k in 1:length(taps)-1 + left = t - k < 1 ? 2 * values[1, node] - values[1+k-t+1, node] : values[t-k, node] + right = t + k > nt ? 2 * values[nt, node] - values[2nt-t-k, node] : values[t+k, node] + value = muladd(taps[k+1], left + right, value) + end + value +end + +"""The interior samples' FIR, one pass: each sample's sum in the order the taps give it +(the centre, then each pair), contracted as `filtered` contracts it, with a fifth of +the tap-at-a-time passes' memory traffic. The taps are a tuple, so the sum unrolls and +the samples vectorise.""" +@noinline function fir_interior!(out, values, node, first, last, taps::NTuple{N}) where {N} + @inbounds @simd for t in first:last + value = taps[1] * values[t, node] + for k in 1:N-1 + value = muladd(taps[k+1], values[t-k, node] + values[t+k, node], value) + end + out[t, node] = value + end +end + +"""Integrate one column of `values` into `out`, sequentially down the column. + +Exact zero support is skipped: reflection cannot carry the live interval past the +filter's radius, since its endpoint is then live already. Interior samples apply the +taps one at a time over the whole interval, which a CPU vectorises without reordering +any one sample's additions. +""" +@inline function integrate_column!(out, values, node, taps, dt) + nt = size(values, 1) + half = length(taps) - 1 + first, last = 1, nt + @inbounds while first <= nt && iszero(values[first, node]) + first += 1 + end + if first > nt + @inbounds for t in 1:nt + out[t, node] = 0 + end + return nothing + end + @inbounds while iszero(values[last, node]) + last -= 1 + end + first, last = max(1, first - half), min(nt, last + half) + @inbounds for t in 1:first-1 + out[t, node] = 0 + end + interior_first, interior_last = max(first, half + 1), min(last, nt - half) + @inbounds for t in first:interior_first-1 + out[t, node] = filtered(values, t, node, taps) + end + @inbounds for t in interior_last+1:last + out[t, node] = filtered(values, t, node, taps) + end + fir_interior!(out, values, node, interior_first, interior_last, Tuple(taps)) + @inbounds previous = out[1, node] + total = zero(dt) + @inbounds out[1, node] = 0 + stop = min(nt, last + 1) + @inbounds for t in max(2, first):stop + current = out[t, node] + total += dt * (current + previous) / 2 + out[t, node] = total + previous = current + end + @inbounds for t in stop+1:nt + out[t, node] = total + end + nothing +end + +"""One column's rates and exposure; return the peak rate. + +`scaled_rate` at every sample, in three passes: the samples whose rate is zero or the +cap are written and the others gathered (their index into `live`, their field into +`scratch`); the gathered ones are evaluated in a loop the CPU vectorises, with +`vlog` and `vexp`; and scattered back. The carrier takes the field across the +table's lower edge twice a cycle, a branch no predictor follows, which kept the +logarithm and exponential scalar and discarded them in flight (argon's rates 2.1 ms +-> 0.7 ms a source on one thread, its plasma 4.7 ms -> 2.9 ms). A NaN field is live +and stays NaN. +""" +@inline function exposure_column!(rate, exposure, nodes, node, taps, dt, args, live, scratch, knots) + scale, table, lower, upper, cap = args[1], args[2], args[3], args[4], args[5] + origin, step = args[6], args[7] + none = zero(dt) + live_count = 0 + @inbounds for t in axes(nodes, 1) + x = abs(scale * nodes[t, node]) + rate[t, node] = x < lower ? none : cap + live[live_count+1, node] = t + scratch[live_count+1, node] = x + live_count += !(x < lower) & !(x >= upper) + end + live_rates!(scratch, knots, node, live_count, table, cap, origin, step) + @inbounds for i in 1:live_count + rate[live[i, node], node] = scratch[i, node] + end + peak = none + @inbounds for t in axes(nodes, 1) + peak = max(peak, rate[t, node]) + end + integrate_column!(exposure, rate, node, taps, dt) + peak +end + +"""The plasma current of each node of a chunk, gated by the window and the collar. + +On a CPU each node's column is one task, scanned in order with its exact zero support +skipped. On a GPU, where a column a thread leaves most of the device idle, every +pass is a sample a thread and the two running integrals are column-wise scans: their +sums are reassociated, which SEP 25 permits and the tests bound, as native's +two-level device scans do. +""" +function plasma_current!(p, nodes, c, count) + is_envelope(p) && return envelope_current!(p, nodes, c, count) + each_channel(p) do q, add + oncpu(c) && !SAMPLE_PLASMA[] ? plasma_columns!(q, nodes, c, count, add) : + plasma_samples!(q, nodes, c, count, add) + end +end + +"""Call `f(q, add)` for each plasma channel: `q` the workspace with the channel's rate +table, constants and population tables in place of the first's, `add` whether its +currents add to those the channels before it formed.""" +function each_channel(f::F, p) where {F} + for (k, channel) in enumerate(p.channels) + # (The channel's every table: an envelope's carries its precise rate's tails.) + q = k == 1 ? p : + merge(p, channel, (fractions=view(p.fractions_all, :, k), peaks=view(p.peaks_all, :, k), + channel=k)) + f(q, k > 1) + end +end + +"""The channels' population tables for the host: a vector for one channel, a +(channel, node) matrix for several.""" +channel_rows(a) = size(a, 2) == 1 ? Vector{Float64}(Array(a)[:, 1]) : + Matrix{Float64}(permutedims(Array(a))) +# SOLPROP_JULIA_PLASMA=samples takes the GPU's path on a CPU too. +const SAMPLE_PLASMA = Ref(false) + +"""`out` = the running trapezoid of the FIR-filtered `values`, every column at once.""" +function integrate_samples!(out, values, taps, dt, c, count) + nt = size(values, 1) + half, none = dt / 2, zero(dt) + # Each trapezoid increment filters its two samples itself: the same values as a + # filtered pass and then an increments pass, one kernel and one memory pass fewer. + each!(c, nt, count) do t, n + @inbounds out[t, n] = t == 1 ? none : + half * (filtered(values, t, n, taps) + filtered(values, t - 1, n, taps)) + end + tally!(:scan) + scan_columns!(@view(out[:, 1:count]), c, zero(dt)) + nothing +end + +function plasma_samples!(p, nodes, c, count, add=false) + T = typeof(p.dt) + (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative) = p + window, floor = c.window, p.floor + args = rate_arguments(p) + charge, potential = T(p.parameters[6]), T(p.parameters[7]) + k = p.channel + dens = stage_scalar(c, 2k, p.parameters[8]) + init = stage_scalar(c, 2k + 1, p.parameters[9]) + nt, none = size(nodes, 1), zero(T) + each!(c, nt, count) do t, n + @inbounds rate[t, n] = scaled_rate(nodes[t, n], args...) + end + integrate_samples!(fraction, rate, taps, dt, c, count) + each!(c, nt, count) do t, n + @inbounds begin + initial = stage_value(init) + exposure = floor ? max(fraction[t, n], none) : fraction[t, n] + value = 1 - (1 - initial) * exp(-exposure) + fraction[t, n] = value + integrand[t, n] = value * charge * nodes[t, n] + end + end + integrate_samples!(current, integrand, taps, dt, c, count) + each!(c, nt, count) do t, n + @inbounds begin + field = nodes[t, n] + squared = field * field + loss = rate[t, n] > 0 && squared > 0 ? + (potential * rate[t, n] * (1 - fraction[t, n]) / squared) * field : none + total = stage_value(dens) * (current[t, n] + loss) + if add + gated[t, n] += window[t] * total + edge[t, n] += derivative[t] * total + else + gated[t, n] = window[t] * total + edge[t, n] = derivative[t] * total + end + end + end +end + +function plasma_columns!(p, nodes, c, count, add=false) + T = typeof(p.dt) + (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative, live, scratch, knots) = p + window, floor = c.window, p.floor + args = rate_arguments(p) + charge, potential = T(p.parameters[6]), T(p.parameters[7]) + density, initial = T(p.parameters[8]), T(p.parameters[9]) + nt = size(nodes, 1) + none = zero(T) + each_column!(c, count) do node + peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live, scratch, knots) + # With exactly zero rates and no initial electrons both currents vanish. + if iszero(peak) && iszero(initial) + # (A later channel adds nothing.) + add || @inbounds for t in 1:nt + gated[t, node] = 0 + edge[t, node] = 0 + end + return nothing + end + fraction_column!(fraction, integrand, nodes, node, initial, charge, floor) + integrate_column!(current, integrand, node, taps, dt) + currents_column!(gated, edge, nodes, rate, fraction, current, window, derivative, + node, potential, density, add) + nothing + end +end + +clear_plasma!(::Nothing) = nothing +clear_plasma!(p) = foreach(a -> fill!(a, 0), (p.projected, p.edge_projected, p.coarse, p.coarse_edge)) + +function project_plasma!(p, c, first, last, quadrature, alpha=true) + count = last - first + 1 + for (values, full, coarse) in ((p.gated, p.projected, p.coarse), (p.edge, p.edge_projected, p.coarse_edge)) + block = @view values[:, 1:count] + gemm!(full, block, table_rows(c, c.projection, first, last), alpha, true, c) + quadrature && c.embedded && + gemm!(coarse, block, table_rows(c, c.projection_coarse, first, last), alpha, true, c) + end +end + +"""Add `-i J / omega + edge / omega^2` of the projected currents to a spectrum.""" +function add_plasma!(destination, p, plan, c; coarse=false, direct=false) + mul!(p.spectrum, plan, direct ? p.gated : coarse ? p.coarse : p.projected) + mul!(p.edge_spectrum, plan, direct ? p.edge : coarse ? p.coarse_edge : p.edge_projected) + add_plasma_spectra!(destination, p, c) +end +"""Add `-i J / omega + edge / omega^2` of the currents' spectra, already transformed.""" +function add_plasma_spectra!(destination, p, c; coarse=false) + is_envelope(p) && return add_envelope_spectra!(destination, p, c) + # The coarse quadrature's currents (a GPU's packed streams), or the source's. + spectrum, edge_spectrum = coarse ? (p.coarse_spectrum, p.coarse_edge_spectrum) : + (p.spectrum, p.edge_spectrum) + inverse_omega = p.inverse_omega + crop, mask = c.crop, c.mask + each!(c, length(crop), size(destination, 2)) do f, m + @inbounds if mask[f] + k = crop[f] + inverse = inverse_omega[f] + destination[k, m] += -im * inverse * spectrum[k, m] + inverse^2 * edge_spectrum[k, m] + end + end +end + +"""Fresh accepted-field populations, for an observation: rates and exposure only. + +Return the six diagnostics' maxima over the chunk (`plasma_integration_statistics`), +and set its nodes' final fractions and peak rates. A GPU forms them a sample a thread, +with the column diagnostics as array reductions, as it forms the current. +""" +population_parts!(p, nodes, c, first, count) = + is_envelope(p) ? envelope_populations!(p, nodes, c, first, count) : + oncpu(c) && !SAMPLE_PLASMA[] ? population_columns!(p, nodes, c, first, count) : + population_samples!(p, nodes, c, first, count) + +function population_samples!(p, nodes, c, first, count) + T = typeof(p.dt) + (; rate, fraction, integrand, current, gated, edge, taps, dt, fractions, peaks) = p + floor, args = p.floor, rate_arguments(p) + initial, none = T(p.parameters[9]), zero(T) + nt, reach = size(nodes, 1), 2 * (length(taps) - 1) + each!(c, nt, count) do t, n + @inbounds rate[t, n] = scaled_rate(nodes[t, n], args...) + end + integrate_samples!(fraction, rate, taps, dt, c, count) + columns = 1:count + # The exposure's steps, then its fractions, the depletion they pay and the integrand. + each!(c, nt, count) do t, n + @inbounds integrand[t, n] = t == 1 ? none : fraction[t, n] - fraction[t-1, n] + end + each!(c, nt, count) do t, n + @inbounds begin + exposure = fraction[t, n] + value = 1 - (1 - initial) * exp(-(floor ? max(exposure, none) : exposure)) + fraction[t, n] = value + gated[t, n] = rate[t, n] * (1 - value) + current[t, n] = abs(value * nodes[t, n]) + end + end + each!(c, nt, count) do t, n + @inbounds edge[t, n] = t == 1 ? none : dt * (gated[t, n] + gated[t-1, n]) / 2 + end + # The columns' work sums and peak rates as device reductions, each column's final + # fraction, peak and defect by a small kernel, and the six maxima as one reduction + # over every sample, read back once: the separate reductions and view copies were + # seven waits and two slow copies a chunk (each about 0.2 ms on Metal). A thread a + # column, looping down it, was slower still: a capillary has a few columns. + paid = scratch(c, :population_paid, T, 1, count) + peak = scratch(c, :population_peak, T, 1, count) + sum!(paid, @view(edge[:, columns])) + maximum!(peak, @view(rate[:, columns])) + tally!(:launch, 2) + defects = scratch(c, :population_defects, T, 2, count) + each!(c, count, 1) do n, _ + @inbounds begin + freed = fraction[nt, n] - fraction[1, n] + fractions[first+n-1] = fraction[nt, n] + peaks[first+n-1] = peak[1, n] + defects[1, n], defects[2, n] = abs(paid[1, n] - freed), freed + end + end + head, lowest = min(reach, nt), typemin(T) + maxima = reduce_each(tuple_max, (none, none, none, lowest, none, none), c, nt, count) do t, n + @inbounds begin + step, value = integrand[t, n], current[t, n] + first_row = t == 1 + (-step, step, first_row ? defects[1, n] : none, first_row ? defects[2, n] : lowest, + t <= head ? value : none, value) + end + end + Float64[max(0, maxima[1]), max(0, maxima[2]), maxima[3], maxima[4], maxima[5], maxima[6]] +end +"""The elementwise maximum of two tuples, for `reduce_each`.""" +tuple_max(a, b) = map(max, a, b) + +function population_columns!(p, nodes, c, first, count) + T = typeof(p.dt) + (; rate, fraction, taps, dt, fractions, peaks, parts, live, scratch, knots) = p + floor, args = p.floor, rate_arguments(p) + initial = T(p.parameters[9]) + nt, reach = size(nodes, 1), 2 * (length(taps) - 1) + none = zero(T) + each_column!(c, count) do node + peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live, scratch, knots) + dip = rise = paid = early = largest = none + before = product_before = start = none + @inbounds for t in 1:nt + exposure = fraction[t, node] + if t > 1 + dip = max(dip, before - exposure) + rise = max(rise, exposure - before) + end + before = exposure + value = 1 - (1 - initial) * exp(-(floor ? max(exposure, none) : exposure)) + fraction[t, node] = value + product = rate[t, node] * (1 - value) + if t == 1 + start = value + else + # The diagnostic's trapezoid stays ordered and uncontracted: it is a + # defect, a difference of nearly equal sums (strict by SEP 25). + paid += dt * (product + product_before) / 2 + end + product_before = product + integrand = abs(value * nodes[t, node]) + largest = max(largest, integrand) + t <= reach && (early = max(early, integrand)) + end + @inbounds begin + freed = fraction[nt, node] - start + fractions[first+node-1] = fraction[nt, node] + peaks[first+node-1] = peak + parts[1, node], parts[2, node], parts[3, node] = dip, rise, abs(paid - freed) + parts[4, node], parts[5, node], parts[6, node] = freed, early, largest + end + nothing + end + vec(maximum(Array(parts)[:, 1:count]; dims=2, init=zero(T))) +end + +# --- Raman ---------------------------------------------------------------------------- + +"""The Raman workspace: the kernel's spectrum and the drives' transforms. + +With fewer of the M (M + 1) / 2 modal products than nodes, each product of the modes' +time signals is convolved once and a node's convolved drive is their sum weighted by +its synthesis (native's ``raman_modal_products``): the convolution is linear, so this +agrees with convolving the node's own drive to the rounding of the drive's scale. +""" +function raman_workspace(c, host, nt, chunk; modes=0, nodes=0, synthesis=nothing) + host.flag("raman") || return nothing + T, C = c.T, Complex{c.T} + rows, rates = host.array("raman_undamped", Float64), host.array("raman_rates", Float64) + dt = host.real("dt") + # Each term weighted by its component's density and fraction (several components, + # summed into one kernel), or all by one if the adapter gives none. + weights = host.has("raman_weights") ? host.array("raman_weights", Float64) : ones(length(rates)) + kernel = zeros(2nt) + for term in eachindex(rates), t in 1:2nt + kernel[t] += weights[term] * rows[t, term] * exp(-rates[term] * (t - 1) * dt) + end + kernel .*= host.real("raman_fraction") + # The inverse transform is unnormalised: its 1/(2 nt) is folded into the kernel. + # The spectrum is held as `spectrum * 2^-e`, its largest entry in [1, 2), and the + # response's factor takes 2^e (SEP 33, rule 1: a block exponent): in binary32 the + # kernel's small entries are otherwise subnormal, a 1.7 % error in an H2 window. + spectrum = FFTW.rfft(kernel) .* (dt / (2nt)) + e = exponent(maximum(abs, spectrum)) + spectrum .*= exp2(-e) + count = modes * (modes + 1) ÷ 2 + products = !c.envelope && synthesis !== nothing && nodes >= 2 && count < nodes && count <= chunk + columns = products ? count : chunk + drive = dzeros(c, T, 2nt, columns) + frequency = dzeros(c, C, nt + 1, columns) + thg = host.flag("raman_thg") + extra = (;) + if products + pairs = [(m, n) for m in 1:modes for n in m:modes] + weights = [synthesis[m, j] * synthesis[n, j] * (m == n ? 1 : 2) for (m, n) in pairs, j in 1:nodes] + signal = dzeros(c, C, thg ? 0 : nt, thg ? 0 : modes) + extra = (weights=upload(c, T.(weights)), nodal=dzeros(c, T, nt, chunk), + first=upload(c, first.(pairs)), second=upload(c, last.(pairs)), signal=signal, + signal_forward=thg ? nothing : plan(c, plan_fft!, signal, 1), + signal_inverse=thg ? nothing : plan(c, plan_bfft!, signal, 1)) + end + # A varying kernel (a gas gradient's): the rows on the device, rebuilt at a stage whose + # rates or densities differ (`rebuild_raman!`), the block exponent the launch's. + if host.flag("raman_varying") + time_kernel = dzeros(c, T, 2nt, 1) + extra = (extra..., varying=true, rows=upload(c, T.(rows)), + component=host.array("raman_component", Int), + fractions=host.array("raman_fractions", Float64), + weights_device=dzeros(c, T, length(rates)), rates_device=dzeros(c, T, length(rates)), + time_kernel=time_kernel, time_spectrum=dzeros(c, C, nt + 1, 1), + kernel_plan=plan(c, plan_rfft, time_kernel, 1; threads=1), + kernel_scale=T(dt / (2nt) * exp2(-e)), raman_dt=T(dt), last=Ref{Any}(nothing)) + else + extra = (extra..., varying=false) + end + (kernel=upload(c, C.(spectrum)), factor=host.real("raman_factor") * exp2(e), thg=thg, + products=products, drive=drive, frequency=frequency, extra..., + forward=plan(c, plan_rfft, drive, 1; threads=c.raman_fft_threads), + inverse=plan(c, plan_brfft, frequency, 2nt, 1; threads=c.raman_fft_threads)) +end + +"""Convolve the drive's columns with the Raman kernel in place.""" +function convolve!(r, c) + (; drive, frequency, kernel) = r + @section :raman_forward mul!(frequency, r.forward, drive) + each!(c, size(frequency)...) do f, m + @inbounds frequency[f, m] *= kernel[f] + end + @section :raman_inverse mul!(drive, r.inverse, frequency) + nothing +end + +"""Rebuild a varying Raman kernel for a stage's decay rates and component densities: the +response `sum_k n_c(k) f_c(k) R_k(t) exp(-r_k t)` on the device, one transform, scaled as +the launch's spectrum was. A stage that repeats the last rates and densities keeps it.""" +function rebuild_raman!(r, rates, densities, c) + key = (copy(rates), copy(densities)) + r.last[] == key && return nothing + r.last[] = key + T = eltype(r.time_kernel) + weights = [densities[r.component[k]] * r.fractions[r.component[k]] for k in eachindex(rates)] + copyto!(r.weights_device, T.(weights)) + copyto!(r.rates_device, T.(rates)) + rows, w, decay, response, dt = r.rows, r.weights_device, r.rates_device, r.time_kernel, r.raman_dt + terms = length(rates) + each!(c, size(response, 1), 1) do t, _ + @inbounds begin + value = zero(eltype(response)) + for k in 1:terms + value += w[k] * rows[t, k] * exp(-decay[k] * (t - 1) * dt) + end + response[t, 1] = value + end + end + mul!(r.time_spectrum, r.kernel_plan, response) + kernel, spectrum, scale = r.kernel, r.time_spectrum, r.kernel_scale + each!(c, length(kernel), 1) do f, _ + @inbounds kernel[f] = spectrum[f, 1] * scale + end + nothing +end + +"""Convolve each node's drive, `|E|^2` (or half the analytic signal's), with the kernel.""" +function raman_drive!(r, nodes, analytic, c, count) + nt = size(nodes, 1) + drive, thg = r.drive, r.thg + each!(c, 2nt, size(drive, 2)) do t, m + @inbounds drive[t, m] = t > nt || m > count ? zero(eltype(drive)) : + thg ? abs2(nodes[t, m]) : abs2(analytic[t, m]) / 2 + end + convolve!(r, c) +end + +"""Convolve the modal products once a source: `a_m a_n`, or `Re(a_m conj a_n) / 2`.""" +function raman_products!(r, modal, c; signal=nothing) + nt, modes = size(modal) + (; drive, first, second) = r + if r.thg + each!(c, 2nt, size(drive, 2)) do t, p + @inbounds drive[t, p] = t > nt ? zero(eltype(drive)) : modal[t, first[p]] * modal[t, second[p]] + end + else + # The modes' analytic signals: given (formed from the spectrum), or from `modal`. + if signal === nothing + signal = r.signal + analytic_signal!(signal, modal, r.signal_forward, r.signal_inverse, c, modes) + end + each!(c, 2nt, size(drive, 2)) do t, p + @inbounds begin + a, b = signal[t, first[p]], signal[t, second[p]] + drive[t, p] = t > nt ? zero(eltype(drive)) : (real(a) * real(b) + imag(a) * imag(b)) / 2 + end + end + end + convolve!(r, c) +end + +"""A chunk's convolved node drives, rebuilt from the convolved products.""" +raman_nodal!(r, first, last, c, alpha=true) = + gemm!(@view(r.nodal[:, 1:last-first+1]), @view(r.drive[1:size(r.nodal, 1), :]), + @view(r.weights[:, first:last]), alpha, false, c) diff --git a/julia/src/rk4.jl b/julia/src/rk4.jl new file mode 100644 index 000000000..b238a2c09 --- /dev/null +++ b/julia/src/rk4.jl @@ -0,0 +1,74 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# The four register passes of SEP 24's RK4IP. A constant flow's key is the schedule +# run's mean step, from the shared table_steps policy. Each pass also forms the norms +# the march reads: the state's, and the stiffness estimate's two slope differences. + +function rk4!(engine, dz::Float64, key::Float64) + c, w = engine.config, engine.work + T = real_type(engine) + (; y, lab, candidate, error, source, forward) = w + mask = c.norm_mask + h, half, third, sixth = T(dz), T(dz / 2), T(dz / 3), T(dz / 6) + c.free ? free_propagators!(engine, key / 2) : modal_flow!(engine, key / 2) + none = zero(T) + source!(engine, y) + engine.version += 1 + each!(c, size(y)...) do f, m + @inbounds begin + flow = forward[f, m, 1] + y[f, m] *= flow + slope = flow * source[f, m] + error[f, m] = slope + candidate[f, m] = muladd(sixth, slope, y[f, m]) + lab[f, m] = muladd(half, slope, y[f, m]) + end + end + source!(engine, lab) + lower = reduce_each(+, none, c, size(y)...) do f, m + @inbounds begin + slope = source[f, m] + difference = slope - error[f, m] + # The second slope is the third's reference: kept where the first was. + error[f, m] = slope + candidate[f, m] = muladd(third, slope, candidate[f, m]) + lab[f, m] = muladd(half, slope, y[f, m]) + mask[f] ? abs2(difference) : none + end + end + source!(engine, lab) + upper = reduce_each(+, none, c, size(y)...) do f, m + @inbounds begin + slope = source[f, m] + difference = slope - error[f, m] + error[f, m] = difference + candidate[f, m] = muladd(third, slope, candidate[f, m]) + lab[f, m] = forward[f, m, 1] * muladd(h, slope, y[f, m]) + mask[f] ? abs2(difference) : none + end + end + source!(engine, lab) + squared = reduce_each(+, none, c, size(y)...) do f, m + @inbounds begin + new = muladd(sixth, source[f, m], forward[f, m, 1] * candidate[f, m]) + candidate[f, m] = new + mask[f] ? abs2(new) : none + end + end + (Float64(squared), lower > 0 ? 2sqrt(Float64(upper) / Float64(lower)) : NaN) +end + +"""A modal route's RK4IP flow over `h`, `exp(h L)`, in slot one (formed in the wide type +and rounded once), kept while `h` is unchanged.""" +function modal_flow!(engine, h) + engine.propagator_dz == h && return 1 + c, w = engine.config, engine.work + linear, forward = c.linear, w.forward + step = wide_value(c, Float64(h)) + each!(c, size(linear)...) do f, m + @inbounds forward[f, m, 1] = first(wide_exp_pair(step * linear[f, m])) + end + engine.propagator_dz = h + 1 +end diff --git a/julia/src/stages.jl b/julia/src/stages.jl new file mode 100644 index 000000000..4afa146c0 --- /dev/null +++ b/julia/src/stages.jl @@ -0,0 +1,171 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Longitudinal expansions. The translation owns the expansion and its scalar +# evaluation: only fixed term arrays and each stage's weights cross, never a pressure +# law or a material formula. + +function path_workspace(c, host) + host.has("phi_terms") || return nothing + C = Complex{c.T} + # Phi's terms stay in the wide type, as the operator does (modal.jl). + phi, pre = widen_host(wide_eltype(c), host.array("phi_terms", ComplexF64)), host.array("prefactor_terms", C) + stages = 7 + (phi=upload(c, phi), prefactor=upload(c, pre), + delta=zeros(size(phi, 3), stages), weights=zeros(size(pre, 3), stages), + delta_device=dzeros(c, wide_eltype(c), size(phi, 3), stages), + weights_device=dzeros(c, c.T, size(pre, 3), stages), + # Their host staging, kept: a converted copy a trial was two fresh arrays. (Pageable + # on purpose: the driver copies it at once, so the next trial may rewrite it.) + delta_staging=fill(c.wide, size(phi, 3), stages), + weights_staging=zeros(c.T, size(pre, 3), stages), + # Kerr, the first channel's density and preionisation, the taper, then each later + # channel's density and preionisation. + material=[zeros(3, stages); ones(1, stages); + zeros(2 * ((host.has("plasma_count") ? host.int("plasma_count") : 1) - 1), stages)], + tables=Dict{String,Any}(), constants=zeros(4), + # A varying Raman kernel's decay rates (a term a row) and component densities. + raman_rates=zeros(host.flag("raman_varying") ? length(host.array("raman_component", Int)) : 0, stages), + raman_densities=zeros(host.flag("raman_varying") ? length(host.array("raman_fractions", Float64)) : 0, stages)) +end + +"""Take a trial's stage weights: Phi increments, prefactor weights and material scales.""" +function configure_stages!(engine, delta, weights, material) + p = engine.work.path + copyto!(p.delta, Matrix{Float64}(delta)) + copyto!(p.weights, Matrix{Float64}(weights)) + copyto!(p.material, Matrix{Float64}(material)) + if p.delta_device isa Array + copyto!(p.delta_device, widen_host(wide_eltype(engine.config), p.delta)) + copyto!(p.weights_device, real_type(engine).(p.weights)) + else + tally!(:upload, 2) + W, T = wide_eltype(engine.config), real_type(engine) + p.delta_staging .= W.(p.delta) + p.weights_staging .= T.(p.weights) + copyto!(p.delta_device, p.delta_staging) + copyto!(p.weights_device, p.weights_staging) + end + material_stage!(engine, 1) + nothing +end + +"""Make a stage's prefactor, Kerr factor and plasma density current.""" +function material_stage!(engine, stage) + c, w = engine.config, engine.work + p = w.path + (; prefactor) = c + terms, weights = p.prefactor, p.weights_device + each!(c, size(prefactor)...) do f, m + value = zero(eltype(prefactor)) + @inbounds for term in axes(terms, 3) + value += terms[f, m, term] * weights[term, stage] + end + @inbounds prefactor[f, m] = value + end + engine.factor = p.material[1, stage] + engine.taper = p.material[4, stage] + r = w.raman + if r !== nothing && r.varying && !isempty(p.raman_rates) + rebuild_raman!(r, view(p.raman_rates, :, stage), view(p.raman_densities, :, stage), c) + end + if w.plasma !== nothing + w.plasma.parameters[8] = p.material[2, stage] + w.plasma.parameters[9] = p.material[3, stage] + for k in 2:length(w.plasma.channels) + parameters = w.plasma.channels[k].parameters + parameters[8], parameters[9] = p.material[3+2(k-1), stage], p.material[4+2(k-1), stage] + end + end +end + +"""Every stage's propagator pair from the expansion: `exp(+-sum_k phi_k delta_k)`.""" +function path_propagators!(engine) + c, w = engine.config, engine.work + p = w.path + (; forward, inverse) = w + phi, delta = p.phi, p.delta_device + each!(c, size(w.y)...) do f, m + @inbounds for stage in 1:7 + exponent = zero(eltype(phi)) + for term in axes(phi, 3) + exponent += phi[f, m, term] * delta[term, stage] + end + forward[f, m, stage], inverse[f, m, stage] = wide_exp_pair(exponent) + end + end +end + +# --- the stage scalars, read by the engine (SEP 39's staged tables) ------------------ + +"""Hold one of the stage's scalar tables as `PiecewiseChebyshev.packed` gives it: +`phi` and `prefactor` (the expansions' weights), `kerr`, `plasma`, `preionisation` +(densities). A name not bound is the constant case `configure_stages_at!` names.""" +bind_stage_table!(engine, name, edges, lower, upper, c) = + (engine.work.path.tables[String(name)] = + (edges=Vector{Float64}(edges), lower=Float64(lower), upper=Float64(upper), + c=Array{Float64,3}(c)); nothing) + +"""Hold the stage's constants: the Kerr coefficient (0 for none), the state scale's +square, and a constant prefactor's span.""" +bind_stage_constants!(engine, kerr, scale2, low, high) = + (engine.work.path.constants .= (kerr, scale2, low, high); nothing) + +"""A bound table's values at the positions, (n_positions, n_values).""" +function stage_values(table, positions) + out = zeros(length(positions), size(table.c, 3)) + bad = clenshaw_points!(positions, table.edges, table.lower, table.upper, table.c, out) + bad >= 0 && throw(ArgumentError( + "z = $(positions[bad+1]) is outside the represented span " * + "[$(table.edges[1]), $(table.edges[end])]")) + out +end + +"""A trial's stage scalars from the bound tables, then `configure_stages!`. + +`translate.stage.scalars_at`'s values for the fields the engine reads, by the same +operations: Phi's increment from `z0` (the distance, for a constant operator), the +prefactor's weights (one, for a constant prefactor, inside its span), and the Kerr +factor, plasma density and preionisation of each position. +""" +function configure_stages_at!(engine, z0, positions) + path = engine.work.path + tables, (kerr, scale2, low, high) = path.tables, path.constants + zs = Vector{Float64}(positions) + n = length(zs) + delta = if haskey(tables, "phi") + here = stage_values(tables["phi"], zs) + permutedims(here .- stage_values(tables["phi"], [Float64(z0)])) + else + reshape([z1 - z0 for z1 in zs], 1, n) + end + weights = if haskey(tables, "prefactor") + permutedims(stage_values(tables["prefactor"], zs)) + else + for z in zs + low <= z <= high || throw(ArgumentError( + "z = $z m lies outside the table, which covers [$low, $high] m")) + end + ones(1, n) + end + column(name) = haskey(tables, name) ? stage_values(tables[name], zs)[:, 1] : zeros(n) + density = column("kerr") + taper = haskey(tables, "taper") ? stage_values(tables["taper"], zs)[:, 1] : ones(n) + later = [column(name * "_$k") for k in 2:(size(path.material, 1) - 2) ÷ 2 + for name in ("plasma", "preionisation")] + material = permutedims(hcat([kerr * d * scale2 for d in density], + column("plasma"), column("preionisation"), taper, later...)) + # A varying Raman kernel's rates and densities, before the stages are configured + # (whose first stage then rebuilds it). + for k in axes(path.raman_rates, 1) + path.raman_rates[k, 1:n] .= column("raman_rate_$k") + end + for j in axes(path.raman_densities, 1) + path.raman_densities[j, 1:n] .= column("raman_density_$j") + end + configure_stages!(engine, delta, weights, material) +end + +const bind_stage_table_b = bind_stage_table! +const bind_stage_constants_b = bind_stage_constants! +const configure_stages_at_b = configure_stages_at! diff --git a/julia/src/vmath.jl b/julia/src/vmath.jl new file mode 100644 index 000000000..f651966a7 --- /dev/null +++ b/julia/src/vmath.jl @@ -0,0 +1,60 @@ +# Branch-free binary64 `exp` and `log` for loops a CPU vectorises (native's vmath.hpp +# role, ADR-059): each within one ulp of the correctly rounded value on the domain +# below, by Cody-Waite reduction and Taylor polynomials evaluated with explicit +# fused multiply-adds (a library function's own error bound, SEP 25; no fast-math). +# Integers are formed by the 1.5 * 2^52 shift, so AVX2 (no 64-bit conversions) +# vectorises them as well as AVX-512. Other precisions take Base's functions. + +const SHIFT = 6.755399441055744e15 # 1.5 * 2^52: x + SHIFT holds round(x) in its low bits +const INV_LN2 = 1.4426950408889634 +const LN2_HI = 6.93147180369123816490e-01 # ln 2, its low 21 bits zero: n LN2_HI is exact +const LN2_LO = 1.90821492927058770002e-10 +const ONE_BITS = reinterpret(Int64, 1.0) +const SQRT_HALF_BITS = Int64(0x3fe6a09e) << 32 # just below sqrt(1/2)'s bits +const MANTISSA = Int64(0x000fffffffffffff) + +"""Horner's rule with fused steps, `p r + c` for each coefficient in turn, unrolled.""" +@inline horner(r, p, c::Tuple) = horner(r, fma(p, r, first(c)), Base.tail(c)) +@inline horner(r, p, ::Tuple{}) = p + +"""2^q for an integer-valued q in [-1022, 1023], from its bits.""" +@inline pow2(q::Int64) = reinterpret(Float64, (q + 1023) << 52) + +"""`exp(x)`, branch-free; any binary64, NaN to NaN, overflow to Inf, underflow to 0.""" +@inline function vexp(x::Float64) + x = clamp(x, -1000.0, 1000.0) + shifted = fma(x, INV_LN2, SHIFT) + q = reinterpret(Int64, shifted) - reinterpret(Int64, SHIFT) + n = shifted - SHIFT + r = fma(n, -LN2_HI, x) + r = fma(n, -LN2_LO, r) + # exp(r) - 1 - r on |r| <= ln2 / 2 by Taylor's series to r^13 (remainder < 2^-60). + p = horner(r, 1 / 6227020800, (1 / 479001600, 1 / 39916800, 1 / 3628800, 1 / 362880, + 1 / 40320, 1 / 5040, 1 / 720, 1 / 120, 1 / 24, 1 / 6, + 1 / 2)) + u = fma(r * r, p, r) + 1.0 + # 2^q as two factors, so that q from -1443 to 1443 neither wraps nor loses range. + half = q >> 1 + u * pow2(half) * pow2(q - half) +end +vexp(x) = exp(x) + +"""`log(x)` for a positive normal binary64 (NaN to NaN), branch-free.""" +@inline function vlog(x::Float64) + bits = reinterpret(Int64, x) + # x = m 2^e with m in [sqrt(1/2), sqrt(2)): shift the mantissa's top half down. + adjusted = bits + (ONE_BITS - SQRT_HALF_BITS) + e = (adjusted >> 52) - 1023 + m = reinterpret(Float64, (adjusted & MANTISSA) + SQRT_HALF_BITS) + f = m - 1.0 + s = f / (2.0 + f) + z = s * s + # log(1 + f) = 2 atanh(s) = 2s + s R(z), R(z) = sum_k 2 z^k / (2k + 1), to z^11. + R = z * horner(z, 2 / 23, (2 / 21, 2 / 19, 2 / 17, 2 / 15, 2 / 13, 2 / 11, 2 / 9, + 2 / 7, 2 / 5, 2 / 3)) + half = 0.5 * f * f + k = reinterpret(Float64, e + reinterpret(Int64, SHIFT)) - SHIFT + value = fma(k, LN2_HI, f - (half - fma(s, half + R, k * LN2_LO))) + ifelse(x == x, value, x) +end +vlog(x) = log(x) diff --git a/src/solprop/_process.py b/src/solprop/_process.py index 1689be4ae..c6277b172 100644 --- a/src/solprop/_process.py +++ b/src/solprop/_process.py @@ -641,8 +641,12 @@ def parallel_rows[T](n_rows: int, nbytes: int, work: Callable[[slice], T]) -> li list Each call's result, in row order. """ + # The size first: the budget reads the CPU topology from sysfs (a file per CPU), + # which a small pass at every saved plane would otherwise pay each time. + if nbytes < PARALLEL_BYTES: + return [work(slice(0, n_rows))] workers = min(thread_budget().threads, n_rows) - if nbytes < PARALLEL_BYTES or workers <= 1: + if workers <= 1: return [work(slice(0, n_rows))] edges = [n_rows * index // workers for index in range(workers + 1)] with ThreadPoolExecutor(workers) as pool: diff --git a/src/solprop/backends/julia/__init__.py b/src/solprop/backends/julia/__init__.py new file mode 100644 index 000000000..f6fbfe5eb --- /dev/null +++ b/src/solprop/backends/julia/__init__.py @@ -0,0 +1,9 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""The Julia backend experiment: CPU, or an NVIDIA GPU with ``SOLPROP_JULIA_DEVICE``.""" + +from solprop.backends.julia._backend import JuliaBackend +from solprop.backends.julia._runtime import source_digest + +__all__ = ["JuliaBackend", "source_digest"] diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py new file mode 100644 index 000000000..193ba496a --- /dev/null +++ b/src/solprop/backends/julia/_backend.py @@ -0,0 +1,1653 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Adapt the existing step driver to the experimental Julia-owned state.""" + +import dataclasses +import logging +import math +import os +from collections.abc import Mapping, Sequence +from typing import Literal + +import numpy as np +from jaxtyping import Complex + +from solprop import fourier +from solprop._process import _BlasLease +from solprop.backends.driver import StepDriver, refuse_general_leaves +from solprop.backends.exponential import refuse_carrier_frame +from solprop.backends.julia._helpers import JULIA +from solprop.backends.julia._march import JuliaAdamsMarch +from solprop.backends.julia._runtime import ( + call_julia, + runtime, + source_digest, + thread_limit, +) +from solprop.backends.multistep import source_absent +from solprop.backends.numpy_ref.passes import plasma_integration_statistics +from solprop.backends.spatial import ( + _axis_statistics, # pyright: ignore[reportPrivateUsage] - the reference's own form + collect_spatial, + fluence_budget, + radial_absorber_matrix, + signed_fluence_widths, +) +from solprop.constants import EPS0, C +from solprop.exceptions import BackendError, ConvergenceError +from solprop.grid import TimeGrid +from solprop.modes.protocol import Mode +from solprop.monitor import BoundaryEnergies, BoundaryMonitor +from solprop.noise import NoiseRealisation +from solprop.output.schema import SavedPlane +from solprop.profiles import ZProfile +from solprop.stats import ( + _POYNTING_STATISTICS, + ON_AXIS_PLASMA_STATISTICS, + StatsSpec, + _power_half_width, + _poynting_statistics, + collect, + default_spec, +) +from solprop.stepper import LowStorageRungeKutta, Multistep +from solprop.stepper.tableau import DOPRI5, TSIT5 +from solprop.translate.chebyshev import PiecewiseChebyshev +from solprop.translate.envelope_plasma import EnvelopePlasmaAssembly +from solprop.translate.linop import power_weight_at +from solprop.translate.precision import launch_peak, state_scale +from solprop.translate.problem import KernelProblem +from solprop.translate.spatial import axial_admittance +from solprop.translate.stage import terms +from solprop.transverse_monitor import TransverseEdge, _EdgeReading + +__all__ = ["JuliaBackend"] + + +logger = logging.getLogger(__name__) +_SPECIES_STATS = frozenset( + ( + "species_density", + "species_electron_density", + "species_ionisation", + "species_ionisation_energy", + "species_peak_ionisation_rate", + "electron_density", + "peak_ionisation_rate", + "plasma_undershoot", + "plasma_work_defect", + "plasma_boundary_level", + ) +) +# Beyond the defaults, the statistics the shared host functions form from the state +# alone (the windows, the zero-dispersion wavelength, a spatial run's temporal ones). +_HOST_STATS = frozenset(("energy_window", "peak_power_window")) +_SUPPORTED_STATS = ( + frozenset(default_spec("multimode", with_profiles=True).names) + | _SPECIES_STATS + | _HOST_STATS + | {"peak_intensity", "quadrature_error", "zdw"} + | frozenset(ON_AXIS_PLASMA_STATISTICS) +) +_SPATIAL_STATS = ( + frozenset(default_spec("radial", with_profiles=True).names) + | _SPECIES_STATS + | _HOST_STATS +) + + +_SPATIAL_LOCAL = frozenset(("peak_intensity", "beam_radius", "fwhm_r")) +_SPATIAL_AXIS = frozenset( + ("on_axis_spectrum", "on_axis_intensity", "beam_radius", "fwhm_r") +) +_SPATIAL_OWNED = frozenset(("energy",)) | _SPATIAL_LOCAL | _SPATIAL_AXIS +"""The spatial statistics the backend forms itself (``JuliaBackend._spatial``).""" + + +def _constant(table: PiecewiseChebyshev | None) -> bool: + """Check the whole polynomial, not just samples at a few positions. + + Parameters + ---------- + table : solprop.translate.chebyshev.PiecewiseChebyshev or None + Translated scalar table. + + Returns + ------- + bool + Whether the table is absent or constant over every interval. + """ + if table is None: + return True + coefficients = table.coefficients + return bool( + np.all(coefficients[:, 1:] == 0) + and np.all(coefficients[:, 0] == coefficients[0, 0]) + ) + + +def _wide(single: bool) -> str: + """Return the wide type of the operator's exponents and the Adams flow. + + A binary64 run forms them in binary64. A binary32 run forms them in binary64 too, + unless ``SOLPROP_JULIA_WIDE=df32`` asks for a double-float (a pair of binary32s, + about 48 bits; ``julia/src/dfloat.jl``). On Metal it is always a double-float, since + an Apple GPU has no binary64. + + Parameters + ---------- + single : bool + Whether the run is in binary32. + + Returns + ------- + str + ``"binary64"`` or ``"df32"``. + + Raises + ------ + BackendError + If the variable names neither, or binary64 on Metal. + """ + metal = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") == "metal" + wide = os.environ.get("SOLPROP_JULIA_WIDE", "df32" if metal else "binary64") + if wide not in {"binary64", "df32"}: + raise BackendError("SOLPROP_JULIA_WIDE must be binary64 or df32") + if metal and wide != "df32": + raise BackendError( + "julia on metal requires SOLPROP_JULIA_WIDE=df32: Apple GPUs have no " + "binary64 arithmetic" + ) + return wide if single else "binary64" + + +def _refuse(problem: KernelProblem) -> None: + """Refuse unsupported leaves before starting Julia or allocating its state. + + Parameters + ---------- + problem : solprop.translate.problem.KernelProblem + Translated schema contract. + + Raises + ------ + BackendError + If a requested leaf is outside the experiment's scope. + """ + response, transform, stepper = ( + problem.responses, + problem.transform, + problem.stepper, + ) + reasons = { + "single batch and scalar polarisation": problem.shape[0] != 1 + or problem.shape[2] != 1 + or transform.n_pol != 1, + "planar transforms": transform.geometry is not None + and transform.geometry.kind not in {"radial", "free"}, + "nonseparable longitudinal tables": not terms(problem).device_ready, + # Several components sum into one kernel (each term weighted by its density + # and fraction); they must agree on the third harmonic. + "Raman components that disagree on the third harmonic": len( + {r.thg for r in response.raman_terms} + ) + > 1, + # A varying Raman kernel is rebuilt at each stage by the stage machinery, + # which a varying operator brings (a gas gradient's); free space has none. + "varying Raman coefficients beside a constant operator": _raman_varying(problem) + and problem.linear.phi_expansion is None, + "varying Raman coefficients in free space": _raman_varying(problem) + and transform.kind == "free", + "dispersive Kerr": response.dispersive_kerr is not None, + "separable responses off free space": response.separable is not None + and transform.kind != "free", + "TDSE": problem.tdse is not None, + "noise": problem.flags.has_noise, + "interaction or comparison Adams integration": isinstance( + stepper.integrator, Multistep + ) + and ( + type(stepper.integrator) is not Multistep + or stepper.integrator.formulation != "exponential" + ), + # A modal route's RK4IP flow is the constant operator's exponential; a + # varying one's (an integral over the half step) is not formed. + "low-storage integration with a varying operator": isinstance( + stepper.integrator, LowStorageRungeKutta + ) + and transform.kind != "free" + and _varying(problem), + # The trial reads its tableau's rows; both are 7-stage first-same-as-last. + "tableaux other than DOPRI5 and TSIT5": stepper.tableau not in (DOPRI5, TSIT5), + "interpolated planes": stepper.interpolate_planes, + } + if ( + os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") == "metal" + and not problem.precision.single + ): + raise BackendError( + "julia on metal does not support precision='double': Apple GPUs have no " + "binary64 arithmetic" + ) + _wide(problem.precision.single) + for reason, refused in reasons.items(): + if refused: + raise BackendError(f"julia does not support {reason}") + refuse_general_leaves(problem, "julia") + refuse_carrier_frame(problem, "julia") + _refuse_stats(problem.stats_spec, spatial=transform.geometry is not None) + from solprop.backends.populations import axis_refusal # noqa: PLC0415 - a cycle + + if reason := axis_refusal(problem, problem.stats_spec.names): + raise BackendError(reason) + + +def _compensated(problem: KernelProblem) -> bool: + """Use the exact chord for structurally absent sources, as SEP 16 requires.""" + return problem.linear.phi_representation in { + "expansion", + "table", + } and not source_absent(problem) + + +def _raman_varying(problem: KernelProblem) -> bool: + """Whether any Raman component's density or decay rate varies along the guide.""" + response = problem.responses + return any( + not _constant(r.density or response.density) + or any(not _constant(v) for v in r.decay_rates) + for r in response.raman_terms + ) + + +def _varying(problem: KernelProblem) -> bool: + """Identify stage-dependent material scales and longitudinal expansions.""" + response = problem.responses + return ( + problem.linear.phi_expansion is not None + or response.prefactor_expansion is not None + or not _constant(response.density) + or ( + response.kerr_coefficients is not None + and not _constant(response.kerr_coefficients.density) + ) + or any( + not _constant(c.density) or not _constant(c.preionisation) + for c in response.population_channels + ) + or _raman_varying(problem) + ) + + +def _refuse_stats(spec: StatsSpec, *, spatial: bool = False) -> None: + """Name statistics outside the prototype's declared scope. + + Parameters + ---------- + spec : solprop.stats.StatsSpec + Requested statistics. + spatial : bool, optional + Whether to use the spatial default/profile statistics subset. + + Raises + ------ + BackendError + If any requested statistic is unsupported. + """ + if missing := set(spec.names) - (_SPATIAL_STATS if spatial else _SUPPORTED_STATS): + raise BackendError(f"julia does not support statistics {sorted(missing)}") + + +def _envelope_configuration( + envelope: EnvelopePlasmaAssembly, scale: float +) -> dict[str, object]: + """Return the envelope grid's plasma for the engine (julia/src/envelope.jl). + + Each channel's instantaneous table and constants as the field plasma's, the cycle + quadrature's rules end to end, and the currents' spectral factors on the band. + + Parameters + ---------- + envelope : solprop.translate.envelope_plasma.EnvelopePlasmaAssembly + The compiled channels and factors. + scale : float + The binary32 state's scale (1 in binary64). + + Returns + ------- + dict + Configuration entries. + + Raises + ------ + BackendError + If the channels' quadrature rules differ. + """ + config: dict[str, object] = { + "envelope_plasma": True, + "plasma_count": len(envelope.channels), + } + for k, channel in enumerate(envelope.channels, start=1): + suffix = "" if k == 1 else f"_{k}" + table = channel.cycle.rate + config[f"plasma_coefficients{suffix}"] = table.coefficients.copy() + config[f"plasma_parameters{suffix}"] = np.array( + [ + table.field_min, + table.field_max, + table.rate_max, + table.log_field_min, + table.d_log_field, + channel.charge_mass_ratio, + channel.ionisation_potential / scale**2, + float(channel.density(0.0)), + float(channel.preionisation(0.0)), + ] + ) + rules = envelope.channels[0].cycle.rules + for channel in envelope.channels: + theirs = channel.cycle.rules + if len(theirs) != len(rules) or any( + not np.array_equal(a.nodes, b.nodes) + for a, b in zip(theirs, rules, strict=True) + ): + raise BackendError("julia does not support channels with different rules") + config.update( + envelope_rule_nodes=np.concatenate([r.nodes for r in rules]), + envelope_rule_weights=np.concatenate([r.weights for r in rules]), + envelope_rule_orders=np.array([len(r.nodes) for r in rules], dtype=np.int64), + envelope_drude=envelope.factors.drude.copy(), + envelope_loss=envelope.factors.loss.copy(), + ) + return config + + +def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: + """Copy the validated constant seam into Julia's frequency-first layout. + + Parameters + ---------- + problem : solprop.translate.problem.KernelProblem + Validated constant scalar modal or spatial contract. + threads : int + Positive Julia task limit. + + Returns + ------- + dict + Owning arrays and scalar configuration consumed once by Julia. + """ + grids, responses, transform = problem.grids, problem.responses, problem.transform + shape = problem.shape + kerr = responses.kerr_coefficients + density = ( + kerr.density + if kerr is not None and kerr.density is not None + else responses.density + ) + factor = ( + 0.0 if kerr is None else kerr.coefficient * float(density.coefficients[0, 0]) + ) + control, tableau = problem.stepper.controller, problem.stepper.tableau + # One pool runs every pass, transforms and products included (julia/src/launch.jl): + # a transform is split into at most this many blocks of whole columns. + fft_threads = thread_limit("SOLPROP_JULIA_FFT_THREADS", threads) + # A binary32 run holds its state as a / s (SEP 33, rule 2): the cubic responses + # take s**2, the plasma reads the physical field s E (the engine's) and its loss + # potential 1 / s**2, and the controller's absolute tolerance is divided by s. + single = problem.precision.single + scale = ( + state_scale(launch_peak(problem.initial.field0, problem.grid_kind)) + if single + else 1.0 + ) + factor *= scale**2 + config: dict[str, object] = { + "precision": "single" if single else "double", + "wide": _wide(single), + "state_scale": scale, + "adams_order": problem.stepper.integrator.order + if isinstance(problem.stepper.integrator, Multistep) + else 0, + "adams_compensated": _compensated(problem), + "plasma": bool(responses.plasma_channels), + "raman": bool(responses.raman_terms), + "envelope": problem.grid_kind == "envelope", + "low_storage": isinstance(problem.stepper.integrator, LowStorageRungeKutta), + "free": transform.kind == "free", + "linear": np.zeros( + (0, 0) if transform.kind == "free" else (shape[-1], shape[1]), dtype=complex + ) + if problem.linear.phi_constant is None + else np.broadcast_to(problem.linear.phi_constant, shape)[0, :, 0, :].T.copy(), + "prefactor": np.zeros( + (0, 0) if transform.kind == "free" else (shape[-1], shape[1]), dtype=complex + ) + if responses.prefactor_constant is None + else np.broadcast_to(responses.prefactor_constant, shape[1:])[:, 0, :].T.copy(), + # Mode averaging already folds the effective-area conversion into synthesis + # and its reciprocal into prefactor; the shared one-node path uses both. + "synthesis": transform.synthesis.T.copy(), + "projection": transform.projection.T.copy(), + "projection_coarse": transform.projection_coarse.T.copy(), + "spatial_absorber": radial_absorber_matrix(transform, grids.pad_scale).T.copy(), + "embedded": not np.array_equal( + transform.projection, transform.projection_coarse + ), + "crop": grids.crop_index.copy(), + "mask": grids.active_mask.copy(), + "norm_mask": grids.norm_mask.copy(), + "weights": np.ones(shape[-1]) + if control.weights is None + else control.weights.copy(), + "window": grids.t_window_fine.copy(), + "omega_window": grids.omega_window.copy(), + "rate": np.zeros(grids.n_to) + if responses.temporal_absorber_fine is None + else responses.temporal_absorber_fine.copy(), + "coarse_rate": np.zeros(grids.n_t) + if responses.temporal_absorber is None + else responses.temporal_absorber.copy(), + "a": tableau.matrix.copy(), + "b": tableau.solution_weights.copy(), + "e": tableau.error_weights.copy(), + "c": tableau.nodes.copy(), + "factor": factor, + "analytic": kerr is not None and kerr.analytic_signal, + # The envelope's third-harmonic term: its factor and the carrier exp(2 i w0 t). + "harmonic_factor": 0.0 if kerr is None else float(kerr.harmonic_factor), + "carrier": np.zeros(0, dtype=complex) + if problem.grids.carrier_2w0 is None + else problem.grids.carrier_2w0.copy(), + "analytic_factor": 0.0 + if kerr is None + else kerr.self_factor + kerr.conjugate_factor, + "split": responses.absorber_scheme == "split_step", + "rtol": control.rtol, + "atol": control.atol / scale, + "cache_propagators": transform.kind != "free" + and problem.stepper.propagator_mode != "recompute", + "threads": threads, + "fft_threads": fft_threads, + "raman_fft_threads": fft_threads, + "transverse_fft_threads": fft_threads, + "blas_threads": 1, + "chunk": transform.node_chunk, + "device": os.environ.get("SOLPROP_JULIA_DEVICE", "cpu"), + } + + if _varying(problem): + held = terms(problem) + assert held.phi is not None and held.prefactor is not None + config.update( + phi_terms=np.broadcast_to(held.phi, (len(held.phi), *shape))[:, 0, :, 0, :] + .transpose(2, 1, 0) + .copy(), + prefactor_terms=np.broadcast_to( + held.prefactor, (len(held.prefactor), *shape[1:]) + )[:, :, 0, :] + .transpose(2, 1, 0) + .copy(), + ) + + if responses.plasma_channels: + # Each channel's rate table and constants; the first unsuffixed, later ones _k. + config["plasma_count"] = len(responses.plasma_channels) + for k, channel in enumerate(responses.plasma_channels, start=1): + suffix = "" if k == 1 else f"_{k}" + table = channel.rate + config[f"plasma_coefficients{suffix}"] = table.coefficients.copy() + config[f"plasma_parameters{suffix}"] = np.array( + [ + table.field_min, + table.field_max, + table.rate_max, + table.log_field_min, + table.d_log_field, + channel.charge_mass_ratio, + channel.ionisation_potential / scale**2, + float(channel.density(0.0)), + float(channel.preionisation(0.0)), + ] + ) + config.update( + plasma_taps=responses.plasma_integral.taps.copy(), + plasma_floor=responses.plasma_integral.policy == "band", + dt=grids.dt_fine, + window_derivative=grids.t_window_fine_derivative.copy(), + omega=grids.omega.copy(), + ) + + if responses.envelope_plasma is not None: + config.update(_envelope_configuration(responses.envelope_plasma, scale)) + config["dt"] = grids.dt_fine + + if responses.raman_terms: + # Every component's terms in one kernel, each weighted by its density and + # fraction (constant: varying coefficients are refused), the mlx backend's sum. + rows, rates, weights = [], [], [] + for raman in responses.raman_terms: + density = float((raman.density or responses.density)(0.0)) + rows.append(raman.undamped.T) + rates.extend(float(rate(0.0)) for rate in raman.decay_rates) + weights.extend([density * raman.fraction] * len(raman.decay_rates)) + if _raman_varying(problem): + # Each term's component and each component's fraction: the engine forms + # the weights from the stage's densities and rebuilds the kernel. + config["raman_varying"] = True + config["raman_component"] = np.concatenate( + [ + np.full(len(raman.decay_rates), j, dtype=np.int64) + for j, raman in enumerate(responses.raman_terms, start=1) + ] + ) + config["raman_fractions"] = np.array( + [raman.fraction for raman in responses.raman_terms] + ) + config.update( + raman_undamped=np.ascontiguousarray(np.hstack(rows)), + raman_rates=np.array(rates), + raman_weights=np.array(weights), + raman_fraction=1.0, + raman_factor=EPS0 * scale**2, + raman_thg=responses.raman_terms[0].thg, + dt=grids.dt_fine, + ) + + if transform.kind == "free": + data, geometry = problem.linear.separable, transform.geometry + assert data is not None and geometry is not None + config.update( + spatial_shape=geometry.shape, + pad_scale=grids.pad_scale, + spatial_rate=geometry.absorber_rate.copy(), + evanescent_rate=data.evanescent_rate, + ) + for name in ( + "k_squared", + "k_squared_low", + "kperp_sq", + "kperp_sq_low", + "frame", + "spectral_rate", + "prefactor_numerator", + "prefactor_clamped", + "active", + "kperp_rate", + ): + value = getattr(data, name) + assert value is not None + config[name] = value.copy() + return config + + +class JuliaBackend(StepDriver[object]): + """Propagate the experimental scalar core subset with resident Julia kernels. + + Parameters + ---------- + problem : solprop.translate.problem.KernelProblem + Supported modal or spatial problem, in SI units and complex128. + grid : solprop.grid.TimeGrid, optional + Temporal grid, needed for statistics. + modes : collections.abc.Sequence, optional + Modes passed to the shared host statistics functions. + profiles : collections.abc.Mapping, optional + Profiles passed to the shared host statistics functions. + + Raises + ------ + BackendError + If the problem or the private Julia runtime is unsupported. + """ + + name = "julia" + max_batch = 1 + # Shared scalar tables and bookkeeping remain plain Python. Numerical state + # and complete propagation trials stay in Julia. + helpers = JULIA + propagator_default = "tabulate" + # The transverse edge (SEP 40/44) is read by the driver's host reduction. + reads_transverse_edge = True + + def __init__( + self, + problem: KernelProblem, + *, + grid: TimeGrid | None = None, + modes: Sequence[Mode] | None = None, + profiles: Mapping[str, ZProfile] | None = None, + ) -> None: + _refuse(problem) + problem.validate() + super().__init__(problem, grid=grid, modes=modes, profiles=profiles) + self._jl = runtime() + # The loaded module is the one on disk: a source edit after the runtime + # started would otherwise time or test stale code. + self._digest = source_digest() + if str(self._jl.loaded_digest()) != self._digest: + raise BackendError("julia sources changed after the runtime loaded them") + self._threads = thread_limit("SOLPROP_JULIA_THREADS") + self._fixed: dict[str, object] | None = None + self._poynting_weight: np.ndarray | None = None + self._admittance: tuple[object, np.ndarray] | None = None + self._spatial_plane: object | None = None + if not 1 <= self._threads <= int(self._jl.runtime()[1]): + raise BackendError("julia thread count must fit the initialized runtime") + self._engine = call_julia( + self._jl.create, _configuration(problem, self._threads) + ) + self._varying = _varying(problem) + self._scale2 = ( + state_scale(launch_peak(problem.initial.field0, problem.grid_kind)) ** 2 + if problem.precision.single + else 1.0 + ) + if self._varying: + self._bind_stage_tables() + self._prepare_stages(0.0, 0.0) + self._plan_flag = os.environ.get("SOLPROP_FFTW_PLAN") or "measure" + self._weight = ( + np.empty(0) + if problem.transform.geometry is not None + else power_weight_at(problem, 0.0) + ) + self._fsal = False + self._recycle = _responses_recycle(problem) + self._alarm = math.nan + self._alarm_reported = False + self._host_blas = _hold_host_blas() + self._edge_key: tuple[int, bool] | None = None + self._warm_bridge() + if isinstance(problem.stepper.integrator, LowStorageRungeKutta): + from solprop.backends.low_storage import LowStorageMarch # noqa: PLC0415 + + self._low_storage = LowStorageMarch(self, problem.stepper.integrator) + + if isinstance(problem.stepper.integrator, Multistep): + self._adams = JuliaAdamsMarch(self, problem.stepper.integrator) + if self._adams.native: + self._warm_march(self._adams) + + def _warm_march(self, march: JuliaAdamsMarch) -> None: + """Run one attempt of Julia's march over a sliver of the span, then reset. + + The engine's buffers are zeroed again: the march compiles here, not in the + first window. + + Parameters + ---------- + march : solprop.backends.julia._march.JuliaAdamsMarch + The run's march, which Julia's steps. + """ + march._configure() + z0 = float(self._problem.initial.z) + limits, flags = march._bounds(z0 + 1e-9 * (march._policy.z_end - z0)) + call_julia( + self._jl.march_run_b, + self._engine, + np.array([z0, self._proposal]), + np.array([1, 0, 0, 0], dtype=np.int64), + np.empty(0), + np.zeros(0, dtype=bool), + np.zeros(0, dtype=np.int64), + np.zeros(7, dtype=np.int64), + limits, + flags, + ) + call_julia(self._jl.reset_work_b, self._engine) + + def _warm_bridge(self) -> None: + """Call each bridge entry the march reaches with the arguments it will pass. + + The engine compiled and ran its own paths at construction; what is left is + the bridge's per-function wrappers and argument conversions, which otherwise + compile inside a run's first boundary reading or edge read. + """ + _, n_modes, _, n_omega = self._problem.shape + jl, engine = self._jl, self._engine + # A crossing's bucket table is read-only, which is part of its bridge type. + buckets = np.zeros((n_modes, n_omega), dtype=np.uint8) + # Every combination a monitor binds: each is a method of its own. + for columns, table in ( + (None, None), + (np.ones(n_modes), None), + (None, buckets.T), + (np.ones(n_modes), buckets.T), + ): + call_julia(jl.bind_monitor_b, engine, columns, table) + for name in ("state_power", "occupancy", "split_power", "column_energy"): + np.asarray(call_julia(getattr(jl, name), engine)) + free = self._problem.transform.kind == "free" + inverse = None if free else np.eye(n_modes) + call_julia(jl.bind_edge_b, engine, inverse, np.zeros(1, dtype=np.int64)) + call_julia(jl.node_energy, engine) + call_julia(jl.device_name, engine) + self._observed_field(engine) + if self._problem.flags.has_plasma: + call_julia(jl.population_snapshot, engine, None) + if self._weight.size: + # The Poynting transforms' plan is measured here, not at the first plane. + axis = None if self._modes is None else self._on_axis_synthesis(self._modes) + self._bind_poynting(axis) + # A varying guide's weight is bound again at each plane: compiled here too. + call_julia( + jl.rebind_weight_b, + engine, + np.ascontiguousarray(self._weight[:, 0, :].T), + ) + for flux in (False, axis is not None): + np.asarray(call_julia(jl.poynting_b, engine, flux)[0]) + call_julia(jl.bind_monitor_b, engine, None, None) + zeros = np.zeros((n_modes, 1, n_omega), dtype=np.complex128) + owned = self._spatial_owned(self._problem.stats_spec.names, zeros) + if owned and self._grid is not None: + # The local pass's transforms are planned here, not at the first plane. + self._spatial(owned, self._grid, zeros) + self.metadata() + + def _adams_state(self) -> Complex[np.ndarray, "n_batch n_modes n_pol n_omega"]: + """Copy the resident state for rare host persistence and budget reports.""" + return self._observed_field(self._require_state()) + + def _adams_restore( + self, z: float, state: Complex[np.ndarray, "n_batch n_modes n_pol n_omega"] + ) -> None: + """Restore a snapshot field before continuing its resident history.""" + self._state = self._apply_mask(state) + self._z = z + + def _adams_engine( + self, method: Multistep, compensation: Literal["transported", "untransported"] + ) -> object: + """Keep exponential samples in Julia behind the shared Adams controller.""" + from solprop.backends.julia._integrators import JuliaAdams # noqa: PLC0415 + + if compensation != "transported": + raise BackendError( + "julia does not support untransported Adams compensation" + ) + return JuliaAdams(self, method) + + def _low_storage_engine(self, method: LowStorageRungeKutta) -> object: + """Keep RK4IP registers in Julia and reuse the shared schedule march.""" + from solprop.backends.julia._integrators import JuliaRK4 # noqa: PLC0415 + + return JuliaRK4(self, method) + + def _apply_mask( + self, state: Complex[np.ndarray, "n_batch n_modes n_pol n_omega"] + ) -> object: + """Load and mask an initial field in Julia-owned storage. + + Parameters + ---------- + state : numpy.ndarray + Internal field with the canonical seam layout. + + Returns + ------- + object + Opaque Julia engine handle. + """ + # The engine reads a contiguous copy's column-major (n_omega, n_modes) view. + values = np.ascontiguousarray(state[0, :, 0, :], dtype=np.complex128) + call_julia(self._jl.load_b, self._engine, values.T) + self._fsal = False + self._alarm = math.nan + return self._engine + + def set_initial( + self, + field: Complex[np.ndarray, "n_batch n_modes n_pol n_omega"], + noise: NoiseRealisation | None, + *, + z: float = 0.0, + resume: bool = False, + ) -> None: + """Load an owning field and reset the controller and FSAL cache. + + Parameters + ---------- + field : numpy.ndarray + Internal complex128 field of shape (1, n_modes, 1, n_omega). + noise : solprop.noise.NoiseRealisation or None + Must be None for this prototype. + z : float, optional + Initial position in metres. + resume : bool, optional + Whether `field` came back from a saved plane of this run. + + Raises + ------ + BackendError + If noise is supplied or the field is nonfinite. + """ + if noise is not None or not np.all(np.isfinite(field)): + raise BackendError("julia requires finite initial fields without noise") + super().set_initial(field, noise, z=z, resume=resume) + if self._adams is not None: + self._adams.reset() + + def _march_to(self, target: float) -> None: + """Dispatch adaptive and replayed Adams runs to the existing march.""" + if self._adams is None: + super()._march_to(target) + else: + self._adams.march_to(target) + + def _trial_step(self, z: float, dz: float) -> tuple[float, object]: + """Evaluate a trial without changing the accepted state. + + Parameters + ---------- + z : float + Start position, m, at which the existing stage tables are evaluated. + dz : float + Trial step length, m. + + Returns + ------- + float + Dimensionless controller error norm. + object + Opaque engine whose candidate buffer awaits acceptance. + + Raises + ------ + BackendError + If the trial produces a nonfinite norm or state is unavailable. + ConvergenceError + If an envelope plasma's cycle moments did not converge. + """ + self._require_state() + if self._varying: + self._prepare_stages(z, dz) + norm = float(call_julia(self._jl.trial_b, self._engine, dz, nogil=True)) + self._rk_source_evaluations += 6 if self._fsal else 7 + self._fsal = True + if not np.isfinite(norm): + if self._problem.responses.envelope_plasma is not None and bool( + call_julia(self._jl.envelope_failed, self._engine) + ): + # The engine marks a sample whose cycle moments did not converge NaN, + # which the norm carries here; the oracle raises this. + raise ConvergenceError( + "envelope plasma directional moments did not converge by order 512" + ) + raise BackendError("julia produced a nonfinite trial error norm") + return norm, self._engine + + def _prepare_stages(self, z: float, dz: float) -> None: + """Have the engine form a trial's stage scalars from its bound tables. + + Parameters + ---------- + z : float + The trial's anchor, m. + dz : float + Its step, m. + """ + problem = self._problem + nodes = problem.stepper.tableau.nodes + # Resident Adams reads only the first material row and the endpoint's; the + # buffer keeps its shape without evaluating the unused DOPRI nodes. + offsets = ( + [0.0] * (len(nodes) - 1) + [dz] + if isinstance(problem.stepper.integrator, Multistep) + else [float(c) * dz for c in nodes] + ) + call_julia( + self._jl.configure_stages_at_b, + self._engine, + z, + np.array([z + offset for offset in offsets]), + ) + + def _bind_stage_tables(self) -> None: + """Give the engine the stage's scalar tables, which it then reads itself. + + The tables ``translate.stage.scalars_at`` reads for the fields the engine takes, + each as :meth:`~solprop.translate.chebyshev.PiecewiseChebyshev.packed` gives + it: the operator's and the prefactor's expansion weights, the Kerr and plasma + densities and the preionisation. A constant operator or prefactor binds no + table. ``julia/src/stages.jl`` evaluates them by the transcribed Clenshaw pass, + so its values are the bundles' bit for bit (tested). + """ + problem = self._problem + linear, responses = problem.linear, problem.responses + tables: dict[str, PiecewiseChebyshev] = {} + if linear.phi_constant is None and linear.separable is None: + assert linear.phi_expansion is not None + tables["phi"] = linear.phi_expansion.weights + if responses.prefactor_constant is None and responses.separable is None: + assert responses.prefactor_expansion is not None + tables["prefactor"] = responses.prefactor_expansion.weights + kerr = responses.kerr_coefficients + if kerr is not None: + tables["kerr"] = responses.density if kerr.density is None else kerr.density + for k, channel in enumerate(responses.population_channels, start=1): + suffix = "" if k == 1 else f"_{k}" + tables[f"plasma{suffix}"] = channel.density + tables[f"preionisation{suffix}"] = channel.preionisation + if _raman_varying(problem): + # Each term's decay rate and each component's density, for the kernel the + # engine rebuilds when they change. + rates = [t for r in responses.raman_terms for t in r.decay_rates] + for i, table in enumerate(rates, start=1): + tables[f"raman_rate_{i}"] = table + for j, raman in enumerate(responses.raman_terms, start=1): + tables[f"raman_density_{j}"] = raman.density or responses.density + if problem.transform.taper_scale is not None: + # A tapered guide's scale: the synthesis takes it, the projection its + # reciprocal. + tables["taper"] = problem.transform.taper_scale + for name, table in tables.items(): + call_julia(self._jl.bind_stage_table_b, self._engine, name, *table.packed()) + low, high = ( + responses.prefactor_span + if "prefactor" not in tables + else (-math.inf, math.inf) + ) + call_julia( + self._jl.bind_stage_constants_b, + self._engine, + 0.0 if kerr is None else float(kerr.coefficient), + float(self._scale2), + float(low), + float(high), + ) + + def _finish(self, state: object, dz: float) -> object: + """Commit the candidate and apply accepted-step boundary treatments. + + Parameters + ---------- + state : object + Opaque candidate handle returned by the trial. + dz : float + Accepted step length, m. + + Returns + ------- + object + Opaque accepted state handle. + """ + monitor = self._split_monitor if _splits(self._problem) else None + self._alarm = float( + call_julia( + self._jl.commit_b, self._engine, dz, monitor is not None, nogil=True + ) + ) + if monitor is not None: + # What the split collar takes and finds, from the power of the masked + # state before it, which the commit formed: BoundaryMonitor.split_sums. + power = np.asarray(call_julia(self._jl.split_power, self._engine)) + rate = monitor.weights[3] + half = power * np.exp(-0.5 * rate * dz) + self._split_removed += float(power @ -np.expm1(-rate * dz)) + self._split_found = np.concatenate( + [[half.sum()], monitor.weights[:3] @ half] + ) + if self._alarm > 1e-6 and not self._alarm_reported: + self._alarm_reported = True + logger.warning( + "transverse quadrature error %.2e exceeds 1e-6 at z=%.6g m; " + "refine the quadrature", + self._alarm, + self._z + dz, + ) + self._fsal = self._recycle + return state + + def _begin_plane(self) -> None: + """Reset the per-plane quadrature diagnostic's reporting flag.""" + self._alarm_reported = False + + def _observed_field( + self, state: object + ) -> Complex[np.ndarray, "n_batch n_modes n_pol n_omega"]: + """Copy an accepted state back to the canonical host layout. + + Parameters + ---------- + state : object + Opaque accepted state handle. + + Returns + ------- + numpy.ndarray + Independent complex128 host array in the seam layout. + """ + del state + # The engine fills a host array, through its column-major (n_omega, n_modes) + # view, with the pool's threads. + _, n_modes, _, n_omega = self._problem.shape + values = np.empty((n_modes, n_omega), dtype=np.complex128) + call_julia(self._jl.copy_state_b, self._engine, values.T) + return values[None, :, None, :] + + def _bind_monitor(self, monitor: BoundaryMonitor | None) -> None: + """Hold the monitor's column weights and rate buckets in the engine. + + Parameters + ---------- + monitor : solprop.monitor.BoundaryMonitor or None + The run's monitor, or ``None`` to stop. + """ + super()._bind_monitor(monitor) + if monitor is None: + return + crossing = monitor.crossing + # Writable copies, as the warm-up passes: a read-only array is another bridge + # type, and its method compiled inside the first window (118 ms on radial). + call_julia( + self._jl.bind_monitor_b, + self._engine, + None + if monitor.columns is None + else np.array(monitor.columns, dtype=np.float64, copy=True), + None + if crossing is None + else np.array(crossing.buckets, dtype=np.uint8, copy=True).T, + ) + + def _edge_reading( + self, + state: object, + edge: TransverseEdge, + *, + faces: bool = True, + current: bool = False, + full: bool = False, + ) -> _EdgeReading: + """Read the transverse edge from the engine's node and column energies. + + The state-sized sums are the engine's; the face tables act on the short + vectors here. A collar's strip and inward current keep the host reduction. + + Parameters + ---------- + state : object + The backend's state handle. + edge : solprop.transverse_monitor.TransverseEdge + The run's edge. + faces : bool, optional + Whether the nodes, the columns and any collar's strip are wanted. + current : bool, optional + Whether a collar's inward current is wanted. + full : bool, optional + Whether every node is wanted, not only the rows a read uses. + + Returns + ------- + solprop.transverse_monitor._EdgeReading + The reading. + """ + reduction = edge.reduction + if current or (faces and reduction.lines): + return super()._edge_reading( + state, edge, faces=faces, current=current, full=full + ) + if not faces: + return _EdgeReading() + tables = reduction.tables + count = self._problem.shape[1] + rows = ( + np.arange(count) + if full or self._problem.transform.kind == "free" + else (np.asarray(tables.rows)) + ) + key = (id(reduction), bool(full)) + if self._edge_key != key: + inverse = reduction.synthesis() + call_julia( + self._jl.bind_edge_b, + self._engine, + None if inverse is None else np.asarray(inverse), + np.asarray(rows, dtype=np.int64), + ) + self._edge_key = key + nodes = np.asarray(call_julia(self._jl.node_energy, self._engine)) + return _EdgeReading( + faces=tables.faces @ nodes, + clip=tables.clip @ nodes if full else None, + totals=tables.totals @ nodes if full else None, + columns=np.asarray(call_julia(self._jl.column_energy, self._engine)), + ) + + def _boundary_energies(self, state: object) -> BoundaryEnergies: + """Read the monitor's energies from the engine's power, not a state copy. + + Parameters + ---------- + state : object + The accepted state handle. + + Returns + ------- + solprop.monitor.BoundaryEnergies + The reading. + + Raises + ------ + BackendError + If no monitor is attached. + """ + del state + monitor = self._monitor + if monitor is None: + raise BackendError("julia: no boundary monitor is attached") + removed, self._split_removed = self._split_removed, 0.0 + power = np.asarray(call_julia(self._jl.state_power, self._engine)) + crossing = monitor.crossing + return BoundaryEnergies( + float(power.sum()), + monitor.weights @ power, + removed=removed, + found=self._split_found, + occupancy=None + if crossing is None + else np.asarray(call_julia(self._jl.occupancy, self._engine)), + ) + + def stats(self, spec: StatsSpec) -> dict[str, np.ndarray]: + """Collect supported modal or spatial statistics through shared host functions. + + Parameters + ---------- + spec : solprop.stats.StatsSpec + Supported statistic names and any periodic subset. + + Returns + ------- + dict + Owning host arrays, with the leading singleton batch axis. + + Raises + ------ + BackendError + If a requested statistic is not supported or no state is loaded. + """ + spatial = self._problem.transform.geometry is not None + _refuse_stats(spec, spatial=spatial) + if not spec.names: + return {} + if self._varying: + self._weight = power_weight_at(self._problem, self._z) + self._prepare_stages(self._z, 0.0) + state = self._observed_field(self._require_state())[0] + grid = self._require_grid() + if spatial: + delegated = dataclasses.replace( + spec, + names=tuple(n for n in spec.names if n not in _SPECIES_STATS), + periodic=(), + ) + owned = self._spatial_owned(delegated.names, state) + values = self._spatial(set(delegated.names) & owned, grid, state) + rest = tuple(n for n in delegated.names if n not in owned) + if rest: + values.update( + collect_spatial( + dataclasses.replace(delegated, names=rest), + grid, + self._problem.transform, + state, + z=self._z, + flux=self._problem.flux, + profiles=self._profiles, + operator=self._problem.linear.separable, + ) + ) + if _SPECIES_STATS.intersection(spec.names): + values.update(self._populations(spec, self._population_scan())) + return {name: value[None] for name, value in values.items()} + weighted = not np.all(self._weight == 1.0) + owned = ( + (_POYNTING_STATISTICS if weighted else {"peak_intensity"}) + | _SPECIES_STATS + | {"quadrature_error"} + | frozenset(ON_AXIS_PLASMA_STATISTICS) + ) + delegated = dataclasses.replace( + spec, names=tuple(n for n in spec.names if n not in owned), periodic=() + ) + values = collect( + delegated, + grid, + SavedPlane(z=self._z, field=state), + modes=self._modes, + profiles=self._profiles, + ) + if weighted or "peak_intensity" in spec.names: + axis = None + if "peak_intensity" in spec.names: + if self._modes is None: + raise BackendError("julia peak_intensity requires modes") + axis = self._on_axis_synthesis(self._modes) + values.update(self._poynting(spec, grid, state, axis)) + if "quadrature_error" in spec.names: + values["quadrature_error"] = np.asarray(self._alarm) + axis_names = set(ON_AXIS_PLASMA_STATISTICS).intersection(spec.names) + if _SPECIES_STATS.intersection(spec.names) or axis_names: + scan = self._population_scan() + values.update(self._populations(spec, scan)) + if axis_names: + # The shared form (SEP 19): a node on the axis hands over its row of + # this observation's scan, else the axis row is scanned on the host. + axis = self._axis_statistics(state, scan[:2]) + values.update({name: axis[name] for name in axis_names}) + return {name: value[None] for name, value in values.items()} + + def _poynting( + self, + spec: StatsSpec, + grid: TimeGrid, + state: np.ndarray, + axis: np.ndarray | None, + ) -> dict[str, np.ndarray]: + """``stats._poynting_statistics``, its analytic signals formed by the engine. + + The transforms and the on-axis product are the engine's (``poynting``), the + reductions over their short results the reference's own. Windowed statistics + take the host function. + + Parameters + ---------- + spec : solprop.stats.StatsSpec + The requested statistics. + grid : solprop.grid.TimeGrid + The run's grid. + state : numpy.ndarray + The state, (n_modes, n_pol, n_omega), the host copy the plane read. + axis : numpy.ndarray or None + The on-axis synthesis (2, n_modes), for ``peak_intensity``. + + Returns + ------- + dict + The requested Poynting statistics. + """ + names = set(spec.names) & _POYNTING_STATISTICS + if names & {"energy_window", "peak_power_window"}: + return _poynting_statistics(spec, grid, state, self._weight, axis) + values: dict[str, np.ndarray] = {} + density = np.abs(state) ** 2 * self._weight + if "omega0" in names: + total = np.sum(density, axis=-1) + with np.errstate(invalid="ignore", divide="ignore"): + values["omega0"] = np.sum(density * grid.omega, axis=-1) / total + if "energy" in names: + spectral = ( + density + if grid.kind == "envelope" + else density + * np.concatenate(([1.0], np.full(grid.n_omega - 2, 4.0), [1.0])) + ) + values["energy"] = (grid.dt / grid.n_t) * np.sum(spectral, axis=-1) + if names - {"omega0", "energy"}: + wanted = "peak_intensity" in names and axis is not None + self._bind_poynting(axis) + power, flux = call_julia(self._jl.poynting_b, self._engine, wanted) + power = np.asarray(power, dtype=np.float64).T + total_power = np.sum(power, axis=0) + if "peak_power" in names: + values["peak_power"] = np.max(power, axis=-1) + if "peak_power_total" in names: + values["peak_power_total"] = np.asarray(np.max(total_power)) + for name in ("fwhm_t", "fwhm_t_outer"): + if name in names: + values[name] = _power_half_width( + grid, total_power, outermost=name.endswith("outer") + ) + if "peak_intensity" in names: + if axis is None: + msg = ( + "Poynting peak_intensity requires the on-axis synthesis matrix" + ) + raise BackendError(msg) + values["peak_intensity"] = np.asarray( + 0.5 * EPS0 * C * np.max(np.asarray(flux)) + ) + return values + + def _spatial_owned(self, names: tuple[str, ...], state: np.ndarray) -> set[str]: + """Return the spatial statistics this backend forms, of those asked. + + A radial or free plane's energy, on-axis and local statistics, for a single + polarisation with the run's plane measure; the rest are ``collect_spatial``'s. + + Parameters + ---------- + names : tuple of str + The statistics asked. + state : numpy.ndarray + The state, (n_modes, n_pol, n_omega). + + Returns + ------- + set of str + The names :meth:`_spatial` forms. + """ + geometry = self._problem.transform.geometry + if ( + geometry is None + or geometry.kind not in ("radial", "free") + or self._problem.flux is None + or state.shape[1] != 1 + ): + return set() + return set(names) & _SPATIAL_OWNED + + def _spatial( + self, names: set[str], grid: TimeGrid, state: np.ndarray + ) -> dict[str, np.ndarray]: + """``collect_spatial``'s energy, on-axis and local statistics. + + The local ones' transforms and sums are the engine's (``spatial_local!``). The + admittance is the plane's, kept while the plane is the same object (a + medium constant in z has one); the energy and the on-axis statistics are the + reference's operations, and the local pass's sums the engine's. + + Parameters + ---------- + names : set of str + The statistics to form, of :data:`_SPATIAL_OWNED`. + grid : solprop.grid.TimeGrid + The run's grid. + state : numpy.ndarray + The state, (n_modes, 1, n_omega). + + Returns + ------- + dict + The statistics, keyed by name. + """ + if not names: + return {} + transform = self._problem.transform + geometry = transform.geometry + flux = self._problem.flux + assert geometry is not None and flux is not None + plane = flux.at(self._z) + if self._admittance is None or self._admittance[0] is not plane: + self._admittance = ( + plane, + axial_admittance(plane, grid.omega, slice(None)), + ) + admittance = self._admittance[1] + values: dict[str, np.ndarray] = {} + conversion = 0.5 * EPS0 * C + chunks = [ + slice(first, min(first + transform.node_chunk, transform.n_modes)) + for first in range(0, transform.n_modes, transform.node_chunk) + ] + if "energy" in names: + weights = fourier.energy_weights(grid.n_omega, grid.dt, kind=grid.kind) + total = 0.0 + for columns in chunks: + real = np.real(admittance[columns]) + density = np.sum(np.abs(state[columns]) ** 2, axis=1) + total += float( + np.sum( + geometry.spectral_weights[columns, None] + * weights + * real + * density + ) + ) + values["energy"] = np.asarray(conversion * total) + axis_fluence = 0.0 + if names & _SPATIAL_AXIS: + closure = np.conj(admittance)[:, None] * state + axis_values, axis_fluence = _axis_statistics( + names, + grid, + np.einsum("r,rpw->pw", geometry.on_axis, state), + np.einsum("r,rpw->pw", geometry.on_axis, closure), + ) + values.update(axis_values) + if names & _SPATIAL_LOCAL: + if self._spatial_plane is not plane: + synthesis = ( + None + if geometry.kind == "free" + else np.ascontiguousarray(transform.synthesis / grid.pad_scale) + ) + call_julia( + self._jl.bind_spatial_b, + self._engine, + np.ascontiguousarray(np.conj(admittance).T), + synthesis, + transform.node_chunk, + ) + self._spatial_plane = plane + fluence, magnitudes, peaks = ( + np.asarray(part, dtype=np.float64) + for part in call_julia( + self._jl.spatial_local_b, self._engine, grid.dt, conversion + ) + ) + if "peak_intensity" in names: + values["peak_intensity"] = np.asarray(float(np.max(peaks))) + if names & {"beam_radius", "fwhm_r"}: + budget = fluence_budget( + magnitudes, state.shape[1] * grid.n_t + transform.n_modes + ) + widths = signed_fluence_widths(geometry, fluence, budget, axis_fluence) + if "beam_radius" in names: + values["beam_radius"] = np.asarray(widths[:2]) + if "fwhm_r" in names: + values["fwhm_r"] = np.asarray(widths[2]) + return values + + def _bind_poynting(self, axis: np.ndarray | None) -> None: + """Give the engine the power weight, when it is a new one, and the on-axis rows. + + Parameters + ---------- + axis : numpy.ndarray or None + The on-axis synthesis (2, n_modes); bound with the first weight. + """ + if self._poynting_weight is self._weight: + return + weight = np.ascontiguousarray(self._weight[:, 0, :].T) + if self._poynting_weight is None: + call_julia( + self._jl.bind_poynting_b, + self._engine, + weight, + None if axis is None else np.ascontiguousarray(axis), + ) + else: + call_julia(self._jl.rebind_weight_b, self._engine, weight) + self._poynting_weight = self._weight + + def _population_scan(self) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """Scan the held state's populations. + + Returns + ------- + tuple of numpy.ndarray + Each channel's final fraction and peak rate at every node (a row a + channel), and the column diagnostics' maxima. + """ + if not self._problem.flags.has_plasma: + empty = np.zeros((0, self._problem.transform.n_nodes)) + return empty, empty, np.zeros(6) + # The engine reads the state it holds, which is the one observed. + raw = call_julia(self._jl.population_snapshot, self._engine, None) + fractions, peaks = ( + np.atleast_2d(np.asarray(raw[i], dtype=float)) for i in (0, 1) + ) + return fractions, peaks, np.asarray(raw[2], dtype=float) + + def _populations( + self, spec: StatsSpec, scan: tuple[np.ndarray, np.ndarray, np.ndarray] + ) -> dict[str, np.ndarray]: + """Reduce fresh accepted-field populations at an observation.""" + from solprop.backends.populations import population_statistics # noqa: PLC0415 + + fractions, peaks, parts = scan + values = population_statistics(self._problem, self._z, fractions, peaks) + if fractions.shape[0] == 1: + values["peak_ionisation_rate"] = np.asarray( + peaks[0, np.argmax(fractions[0])] + ) + if any(name.startswith("plasma_") for name in spec.names): + values.update( + zip( + ( + "plasma_undershoot", + "plasma_work_defect", + "plasma_boundary_level", + ), + ( + np.asarray(value) + for value in plasma_integration_statistics(parts) + ), + strict=True, + ) + ) + return {name: values[name] for name in spec.names if name in _SPECIES_STATS} + + def metadata(self) -> dict[str, object]: + """Return runtime and thread provenance beside the shared step counters. + + Returns + ------- + dict + JSON-serializable execution metadata, without local paths. + """ + self._check_open() + assert self._engine is not None + return ( + super().metadata() + | self._provenance() + | {"resident_source_evaluations": int(self._engine.calls)} + ) + + def _provenance(self) -> dict[str, object]: + """Return the engine's fixed provenance, read from Julia once. + + A run records the metadata at every plane; these fields do not change. + + Returns + ------- + dict + The runtime, thread and plan fields of :meth:`metadata`. + """ + if self._fixed is not None: + return self._fixed + assert self._engine is not None + version, threads, fft, blas, library = self._jl.runtime() + config = self._engine.config + free = self._problem.transform.kind == "free" + self._fixed = { + "julia_version": str(version), + "julia_source_digest": self._digest, + "device": str(self._jl.device_name(self._engine)), + "julia_wide": _wide(self._problem.precision.single), + "julia_flush_subnormals": os.environ.get("SOLPROP_JULIA_FTZ", "0") == "1", + "propagator_cache": ( + "schedule_run_mean" + if self._low_storage is not None + else "stage_expansion" + if self._varying + else "constant_table_exact_dz" + if self._propagator_mode == "tabulate" + else "disabled" + ), + "julia_threads": int(threads), + "fftw_threads": int(fft), + "modal_fftw_threads": int(config.fft_threads), + "raman_fftw_threads": int(config.raman_fft_threads) + if self._problem.flags.has_raman + else None, + "transverse_fftw_threads": int(config.transverse_fft_threads) + if free + else None, + "blas_threads": int(blas), + "blas_library": str(library), + "plan_flag": self._plan_flag, + "experimental": True, + } + return self._fixed + + def memory_ledger(self) -> dict[str, int]: + """List owned numerical arrays, excluding opaque library plan internals. + + Returns + ------- + dict + Byte counts by Julia buffer name and host table. + """ + self._check_open() + result = self._jl.ledger(self._engine) + return {str(name): int(result[name]) for name in result} | ( + {"host_power_weight": self._weight.nbytes} if self._weight.size else {} + ) + + def close(self) -> None: + """Release this engine's Julia references; repeated calls are harmless.""" + if self._host_blas is not None: + self._host_blas.restore_original_limits() + self._host_blas = None + self._state = None + self._engine = None + self._closed = True + self._rows.clear() + + +def _hold_host_blas() -> _BlasLease | None: + """Hold every host BLAS pool to one thread while the engine lives, as native does. + + NumPy's OpenBLAS spins after each small host product (the transverse edge's + tables, the planes' statistics) on the cores the engine's pool waits on: on eight + Xeon cores a radial filament's window took 4.26 s with its eight threads and 1.07 s + with one. The lease is solprop's (``acquire_host_blas``), shared with native's. + + Returns + ------- + solprop._process._BlasLease or None + The lease, or None when no controllable BLAS is loaded. + """ + import threadpoolctl # noqa: PLC0415 - loaded with the engine only + + from solprop._process import acquire_host_blas # noqa: PLC0415 + + libraries = threadpoolctl.ThreadpoolController().select(user_api="blas") + if not libraries.lib_controllers: + return None + return acquire_host_blas(libraries.lib_controllers, 1) + + +def _splits(problem: KernelProblem) -> bool: + """Return whether accepted steps apply the split-step temporal collar.""" + response = problem.responses + return response.absorber_scheme == "split_step" and ( + response.temporal_absorber is not None + ) + + +def _responses_recycle(problem: KernelProblem) -> bool: + """Decide whether accepted-step absorption preserves the last source. + + Parameters + ---------- + problem : solprop.translate.problem.KernelProblem + Constant modal or spatial contract. + + Returns + ------- + bool + Whether the source can be reused after acceptance. + """ + response = problem.responses + return ( + response.absorber_scheme != "split_step" + or response.temporal_absorber is None + or not np.any(response.temporal_absorber) + ) diff --git a/src/solprop/backends/julia/_helpers.py b/src/solprop/backends/julia/_helpers.py new file mode 100644 index 000000000..9d427b0ee --- /dev/null +++ b/src/solprop/backends/julia/_helpers.py @@ -0,0 +1,98 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""The Julia backend's per-stage and per-step evaluations (SEP 29 section 6.6). + +:data:`JULIA` is the backend's record for solprop's shared code: the Chebyshev rows of +the stage tables and the Adams basis, by the engine's transcriptions in +``julia/src/helpers.jl``, which perform the Python forms' operations in their order, +so the values are numpy_ref's bit for bit. A call costs about 17 us against the +Python pass's 100 us. +""" + +import numpy as np + +from solprop._helpers import BasisFunction, Helpers, PointsFunction +from solprop.backends.julia._runtime import runtime + +__all__ = ["JULIA"] + + +def _load_points() -> PointsFunction: + """Return the engine's Chebyshev rows. + + Returns + ------- + collections.abc.Callable + The :data:`solprop._helpers.PointsFunction` of ``clenshaw_points!``. + """ + function = runtime().clenshaw_points_b + + def points( + z: np.ndarray, + edges: np.ndarray, + lower: float, + upper: float, + c: np.ndarray, + out: np.ndarray, + ) -> int: + """Write a table's rows at the positions into `out`; see ``PointsFunction``. + + Parameters + ---------- + z, edges : numpy.ndarray + The positions and the breakpoints, float64. + lower, upper : float + The span with its slack. + c, out : numpy.ndarray + The coefficients and the values, C-contiguous. + + Returns + ------- + int + The first position outside the span, or -1. + """ + return int(function(z, edges, lower, upper, c, out)) + + return points + + +def _load_basis() -> BasisFunction: + """Return the engine's Adams basis. + + Returns + ------- + collections.abc.Callable + The :data:`solprop._helpers.BasisFunction` of ``basis_rows!``. + """ + function = runtime().basis_rows_b + + def basis( + points: np.ndarray, upper: float, integrate: bool + ) -> tuple[np.ndarray, np.ndarray]: + """Return the basis' coefficients or integrals; see ``BasisFunction``. + + Parameters + ---------- + points : numpy.ndarray + The distinct nodes, float64. + upper : float + The integral's upper limit. + integrate : bool + Whether to return the integrals. + + Returns + ------- + tuple + The coefficients ``(n, n)`` and the integrals ``(n,)``. + """ + n = points.shape[0] + rows, weights = np.zeros((n, n)), np.empty(n) + function(points, float(upper), bool(integrate), rows, weights) + return rows, weights + + return basis + + +JULIA = Helpers("julia", _load_points, _load_basis) +"""The Julia engine's record; a trial's tables are formed in the engine itself.""" diff --git a/src/solprop/backends/julia/_integrators.py b/src/solprop/backends/julia/_integrators.py new file mode 100644 index 000000000..a175c6c08 --- /dev/null +++ b/src/solprop/backends/julia/_integrators.py @@ -0,0 +1,196 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Connect resident Julia integrators to the existing Python march policies.""" + +import math +from collections.abc import Mapping + +import numpy as np + +from solprop.backends.julia._backend import JuliaBackend +from solprop.backends.julia._runtime import call_julia +from solprop.backends.low_storage import schedule_key, table_steps +from solprop.exceptions import BackendError +from solprop.stepper import LowStorageRungeKutta, Multistep +from solprop.translate.linop import rate_weights + + +class JuliaRK4: + """Own the small RK4IP policy while Julia holds all field registers.""" + + atomic = True + + def __init__(self, backend: JuliaBackend, method: LowStorageRungeKutta) -> None: + self.backend = backend + self.method = method + self.stiffness = math.nan + schedule = backend._problem.stepper.schedule + assert schedule is not None + self.keys = table_steps(schedule) + self.edges = schedule.edges + + def step(self, z: float, dz: float) -> float: + """Execute the four resident source passes and return the state norm.""" + backend = self.backend + key = schedule_key(self.keys, self.edges, z, dz) + squared, self.stiffness = call_julia( + backend._jl.rk4_b, backend._engine, dz, key, nogil=True + ) + return float(squared) + + def reset(self) -> None: + """Reset diagnostics after loading an initial state.""" + self.stiffness = math.nan + + def close(self) -> None: + """Release no arrays: the backend owns the resident registers.""" + self.reset() + + +class JuliaAdams: + """Keep exponential PEC samples resident and exchange only scalar trial tables.""" + + dense = None + # The carrier frame is refused at admission (SEP 35 is not delivered here). + carrier = None + + def __init__(self, backend: JuliaBackend, method: Multistep) -> None: + self.backend = backend + self.method = method + assert backend._engine is not None + self.compensated = bool(backend._engine.work.adams.compensated) + self._dz = 0.0 + + @property + def n_slots(self) -> int: + """Return the shared march's required history capacity.""" + return self.method.order + 2 + + def reset(self) -> None: + """Forget the pending trial; startup replaces the first resident row.""" + self._dz = 0.0 + + def start(self, z: float, *, stored: bool) -> None: + """Evaluate the accepted initial state's first source sample.""" + del stored + backend = self.backend + if backend._varying: + backend._prepare_stages(z, 0.0) + if self.compensated: + call_julia( + backend._jl.configure_adams_rate_b, + backend._engine, + rate_weights(backend._problem.linear, z, helpers=backend.helpers), + ) + call_julia(backend._jl.adams_start_b, backend._engine, nogil=True) + + def value(self, slot: int) -> None: + """Keep history rows opaque to the march.""" + del slot + + def hold(self) -> object: + """Refuse dense observation, which admission already refuses.""" + raise BackendError("julia does not support interpolated Adams planes") + + def restore(self, z: float, held: object) -> None: + """Refuse dense observation, which admission already refuses.""" + del z, held + raise BackendError("julia does not support interpolated Adams planes") + + def observe(self, position: float) -> object: + """Refuse dense observation, which admission already refuses.""" + del position + raise BackendError("julia does not support interpolated Adams planes") + + def fused_trial(self, *args: object) -> np.ndarray: + """Refuse the interaction formulation, which admission already refuses.""" + del args + raise BackendError("julia runs the exponential Adams formulation only") + + def fused_accept(self, *args: object, **kwargs: object) -> None: + """Refuse the interaction formulation, which admission already refuses.""" + del args, kwargs + raise BackendError("julia runs the exponential Adams formulation only") + + def snapshot_nbytes(self) -> int: + """Return the bytes :meth:`snapshot_rows` would copy.""" + rows = 3 if self.compensated else 1 + return rows * self.n_slots * math.prod(self.backend._problem.shape) * 16 + + def exponential_trial( + self, + z: float, + dz: float, + nodes: list[float], + slots: np.ndarray, + order: int, + orders: list[int], + ) -> np.ndarray: + """Copy scalar tables, then run the resident trial without the GIL.""" + backend = self.backend + if backend._varying: + backend._prepare_stages(z, dz) + # The tables are formed in the engine (julia/src/helpers.jl), in the shared + # functions' operations and order (backends.multistep.trial_tables). + rate = ( + rate_weights( + backend._problem.linear, z + dz, before=True, helpers=backend.helpers + ) + if self.compensated + else np.empty(0) + ) + call_julia( + backend._jl.configure_adams_nodes_b, + backend._engine, + np.asarray(nodes, dtype=np.float64), + order, + np.asarray(orders, dtype=np.int64), + slots, + rate, + ) + result = call_julia(backend._jl.adams_trial_b, backend._engine, dz, nogil=True) + self._dz = dz + return np.asarray(result, dtype=float).copy() + + def exponential_accept( + self, keep: np.ndarray, free: int, *, interpolate: bool + ) -> None: + """Save the endpoint sample and commit the accepted candidate.""" + del keep + if interpolate: + raise BackendError("julia does not support interpolated Adams planes") + backend = self.backend + call_julia(backend._jl.adams_accept_b, backend._engine, free, nogil=True) + backend._state = backend._finish(backend._engine, self._dz) + + def snapshot_rows(self) -> dict[str, np.ndarray]: + """Copy owning history rows into the existing resume layout.""" + backend = self.backend + names = ("store", "states", "rates") if self.compensated else ("store",) + shape = (self.n_slots, *backend._problem.shape) + return { + name: np.asarray(call_julia(backend._jl.adams_rows, backend._engine, name)) + .transpose(2, 1, 0) + .copy() + .reshape(shape) + for name in names + } + + def load_rows(self, rows: Mapping[str, np.ndarray], shape: tuple[int, ...]) -> None: + """Validate all snapshot rows before replacing the resident history.""" + names = {"store", "states", "rates"} if self.compensated else {"store"} + expected = (self.n_slots, *shape) + if set(rows) != names or any( + row.shape != expected or row.dtype != np.complex128 for row in rows.values() + ): + raise BackendError("julia Adams history does not match the snapshot") + backend = self.backend + for name, row in rows.items(): + call_julia( + backend._jl.adams_load_rows_b, + backend._engine, + name, + row[:, 0, :, 0, :].transpose(2, 1, 0).copy(), + ) + self.reset() diff --git a/src/solprop/backends/julia/_march.py b/src/solprop/backends/julia/_march.py new file mode 100644 index 000000000..881083d35 --- /dev/null +++ b/src/solprop/backends/julia/_march.py @@ -0,0 +1,384 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""The exponential Adams march executed by the Julia engine (SEP 39's native march). + +The algorithm is :class:`~solprop.backends.multistep.AdamsMarch`'s, which stays the +reference: ``julia/src/march.jl`` transcribes it (by way of native's +``adams_march.cpp``) and performs a run of attempts on the resident engine, returning +to Python only at a host event: the target reached, an accepted step on which the +driver has work (a statistics row, a natural stop, a monitor check, a transverse +read), the call's bound, the budget, the floor or an error. Between calls the march's +state is this object's, as the Python march keeps it, so a snapshot, a reset and a +new run are the reference's own. The call protocol, the bounds and the adoption follow +native's ``_NativeAdamsMarch``. + +A configuration the Julia march does not cover runs the Python march +(:attr:`JuliaAdamsMarch.refusal`): a replayed schedule, interpolated planes, the +carrier frame, a compensated trial without an expansion's rate table, or +``SOLPROP_JULIA_MARCH=host``. A split collar's sums are formed from the power each +accepted step's commit found, by the adapter, as its own commit does. +""" + +import logging +import math +import os +import time +from typing import Any + +import numpy as np + +from solprop._interrupts import committing +from solprop.backends.driver import reached +from solprop.backends.julia._runtime import call_julia +from solprop.backends.multistep import ( + AdamsMarch, + _Derivative, # pyright: ignore[reportPrivateUsage] - the march's history entries +) +from solprop.exceptions import BackendError, ConvergenceError +from solprop.stepper import Multistep + +logger = logging.getLogger(__name__) + +__all__ = ["JuliaAdamsMarch"] + +_REACHED, _HOST_STEP, _MONITOR, _BOUND, _BUDGET, _FLOOR, _ERROR, _DIVERGED = range(8) +_CONVERGENCE, _BACKEND, _VALUE = 1, 2, 3 +_COUNTERS = ( + "startup", + "predictor", + "rejected", + "accepted_steps", + "rejected_steps", + "restarts", + "failure_restarts", +) +"""The call ledger's counters the Julia march keeps, in its order.""" + + +class JuliaAdamsMarch(AdamsMarch): + """solprop's exponential Adams march, executed by the Julia engine. + + Parameters + ---------- + backend : solprop.backends.julia.JuliaBackend + The backend whose engine steps. + method : solprop.stepper.Multistep + The exponential Adams method. + """ + + MAX_ATTEMPTS = 256 + """A call's most attempts, the bound on the wait of a signal or a stop flag.""" + MAX_SECONDS = 0.1 + """A call's most wall time, s, read once per attempt.""" + + def __init__(self, backend: Any, method: Multistep) -> None: + """Build the Python march, then decide which march steps the run.""" + super().__init__(backend, method) + # The driver's protected bookkeeping, which this march books into exactly as + # solprop's does (``DRIVER_SURFACE``), as native's march reaches it. + self._driver: Any = backend + self._configured: tuple[float | None, bool] | None = None + self.refusal = self._refusal() + """Why the Python march steps the run, or ``None`` when Julia's does.""" + + @property + def native(self) -> bool: + """Whether the Julia march steps the run.""" + return self.refusal is None + + def _refusal(self) -> str | None: + """Return why the Julia march does not step the run, or ``None``.""" + problem = self._driver._problem + engine: Any = self._engine + reasons = ( + (os.environ.get("SOLPROP_JULIA_MARCH") == "host", "asked for"), + (self._exponential is None, "not the exponential formulation"), + (problem.stepper.schedule is not None, "a replayed schedule"), + (self._interpolate, "interpolated planes"), + (self._policy.carrier, "the carrier frame"), + ( + engine.compensated and problem.linear.phi_expansion is None, + "a compensated trial without an expansion", + ), + ) + return next((reason for failed, reason in reasons if failed), None) + + def march_to(self, target: float) -> None: + """Step the backend's state to `target`, by Julia's march when admitted. + + Parameters + ---------- + target : float + Position to reach, m. + """ + if not self.native: + super().march_to(target) + return + backend = self._driver + if backend._natural_stop_due(target): + return + self._configure() + while not reached(backend._z, target): + if self._call(target): + return + + def _configure(self) -> None: + """Hand the engine the run's policy, again when the monitor's interval moved.""" + from solprop.backends.julia._backend import _splits # noqa: PLC0415 - cycle + + monitor = self._driver._monitor + interval = None if monitor is None else float(monitor.interval) + split = bool( + _splits(self._driver._problem) and self._driver._split_monitor is not None + ) + if self._configured == (interval, split): + return + policy = self._policy + backend = self._driver + problem = backend._problem + engine: Any = self._engine + numbers = np.array( + [ + policy.order, + policy.variable_order, + policy.safety, + policy.max_growth, + policy.min_factor, + policy.rejection_growth, + policy.hysteresis, + policy.restart_after, + policy.collar_stability, + policy.collar_rate, + policy.max_calls is not None, + 0 if policy.max_calls is None else policy.max_calls, + policy.equal_approach, + policy.dz_min, + policy.dz_max, + policy.stretch, + policy.z_end, + policy.landing_ulps, + interval is not None, + 0.0 if interval is None else interval, + ], + dtype=np.float64, + ) + edges = coefficients = np.empty(0) + if engine.compensated: + edges, _, _, coefficients = problem.linear.rate.packed() + call_julia( + backend._jl.configure_march_b, + backend._engine, + numbers, + np.asarray(policy.real_intervals, dtype=np.float64), + np.asarray(policy.save_planes, dtype=np.float64), + np.asarray(policy.hard_kinks, dtype=np.float64), + np.asarray(policy.breakpoints, dtype=np.float64), + len(problem.stepper.tableau.nodes), + bool(backend._varying), + bool(engine.compensated), + split, + np.ascontiguousarray(edges, dtype=np.float64), + np.ascontiguousarray(coefficients, dtype=np.float64) + if engine.compensated + else np.zeros((0, 0, 0)), + ) + self._configured = (interval, split) + + def _bounds(self, target: float) -> tuple[np.ndarray, np.ndarray]: + """Return a call's bounds: the target, and the steps the driver has work on. + + Returns + ------- + tuple of numpy.ndarray + The limits (target, check interval, last check, read position and + spacing, step cap, seconds) and flags (quiet, host step, monitor, first + check, a read due, attempts) of ``march_run!``. + """ + backend = self._driver + steps: list[int] = [] + if backend._row_spec is not None: + period = backend._row_period + steps.append(period - backend._accepted_steps % period) + every = backend._problem.stepper.step_planes + if every: + steps.append(every - backend._natural_count % every) + monitor = backend._monitor + checked = None + read_at = None + spacing = 0.0 + if monitor is not None: + steps.append(monitor.steps_to_check()) + checked = monitor.checked_at + # The transverse edge is read on the host (SEP 40 section 5.3): steps are + # capped at its spacing, and the march returns before one would carry + # past its next read. + edge = monitor.transverse + if edge is not None: + if edge.every_step: + steps.append(1) + if math.isfinite(edge.next_read): + read_at = float(edge.next_read) + spacing = float(edge.ceiling(backend._z)) + limits = np.array( + [ + target, + 0.0 if monitor is None else float(monitor.interval), + 0.0 if checked is None else float(checked), + 0.0 if read_at is None else read_at, + spacing, + math.inf if monitor is None else float(monitor.step_cap), + self.MAX_SECONDS, + ] + ) + flags = np.array( + [ + bool(backend._collar_quiet), + int(min(steps)) if steps else 0, + checked is not None, + False, + read_at is not None, + self.MAX_ATTEMPTS, + ], + dtype=np.int64, + ) + return limits, flags + + def _call(self, target: float) -> bool: + """Make one Julia call and drain it; return whether a natural stop is due.""" + backend = self._driver + backend._poll_stop() + limits, flags = self._bounds(target) + started = time.perf_counter() - backend._clock + history = self._history + with committing(): + result = call_julia( + backend._jl.march_run_b, + backend._engine, + np.array([backend._z, backend._proposal]), + np.array( + [ + self._order, + self._rejections, + self._last_rejected, + self._collar_was_quiet, + ], + dtype=np.int64, + ), + np.array([entry.z for entry in history], dtype=np.float64), + np.array([entry.identity == "predicted" for entry in history]), + np.array([entry.slot for entry in history], dtype=np.int64), + np.array([getattr(self.ledger, name) for name in _COUNTERS]), + limits, + flags, + nogil=True, + ) + self._synchronise(result) + rows = np.asarray(result.rows, dtype=np.float64).reshape(-1, 6) + reason = int(result.reason) + # Only the last accepted row of an event can have the driver's work; the + # others take the skip path, as the reference's would. + event = reason in (_REACHED, _HOST_STEP, _MONITOR) + last = len(rows) - 1 + for index, (end, dz, norm, accepted, _, wall) in enumerate(rows.tolist()): + backend._record_attempt(end, dz, norm, bool(accepted), started + wall) + final = index == last and (event or reason == _FLOOR) + if accepted and not final: + backend._skip_step(end) + progress = backend._progress + for end, dz, norm, accepted, order, _ in rows.tolist(): + progress.step(end, dz, bool(accepted)) + if logger.isEnabledFor(logging.DEBUG): + logger.debug( + "julia Adams attempt to z = %.9g m: dz = %.4g m, order %d, " + "norm %.4g, %s", + end, + dz, + int(order), + norm, + "accepted" if accepted else "rejected", + ) + if event and rows.size and rows[-1, 3]: + backend._take_step_stats() + if backend._natural_stop(target): + return True + self._raise(reason, result) + return False + + def _synchronise(self, result: Any) -> None: + """Adopt the state a Julia call handed back.""" + backend = self._driver + z, proposal = np.asarray(result.zs).tolist() + backend._z, backend._proposal = float(z), float(proposal) + order, rejections, last_rejected, was_quiet = np.asarray(result.counts).tolist() + self._order, self._rejections = int(order), int(rejections) + self._last_rejected, self._collar_was_quiet = ( + bool(last_rejected), + bool(was_quiet), + ) + self._history = [ + _Derivative( + float(z), None, "predicted" if predicted else "accepted", int(row) + ) + for z, predicted, row in zip( + np.asarray(result.history_z).tolist(), + np.asarray(result.history_predicted).tolist(), + np.asarray(result.history_row).tolist(), + strict=True, + ) + ] + ledger = self.ledger + for name, value in zip( + _COUNTERS, np.asarray(result.ledger).tolist(), strict=True + ): + setattr(ledger, name, int(value)) + orders = np.asarray(result.orders).tolist() + ledger.orders.extend(int(order) for order in orders) + steps = np.asarray(result.split_steps).tolist() + if steps: + # Each accepted step's split sums from the power its commit found, by the + # operations `JuliaBackend._finish` performs, step by step. + powers = np.asarray(result.split_powers).reshape(len(steps), -1).T + monitor = backend._split_monitor + rate = monitor.weights[3] + for index, dz in enumerate(steps): + power = np.ascontiguousarray(powers[:, index]) + half = power * np.exp(-0.5 * rate * dz) + backend._split_removed += float(power @ -np.expm1(-rate * dz)) + backend._split_found = np.concatenate( + [[half.sum()], monitor.weights[:3] @ half] + ) + if orders: + # The accepted steps' commits, which the engine made: what `_finish` sets. + backend._alarm = float(result.alarm) + backend._state = backend._engine + backend._fsal = backend._recycle + first = float(result.first_alarm) + if not math.isnan(first) and not backend._alarm_reported: + backend._alarm_reported = True + logger.warning( + "transverse quadrature error %.2e exceeds 1e-6 at z=%.6g m; " + "refine the quadrature", + first, + float(result.alarm_z), + ) + + def _raise(self, reason: int, result: Any) -> None: + """Raise the error a call returned with, if any.""" + if reason == _BUDGET: + raise self._budget_error(int(result.cost)) + if reason == _FLOOR: + proposed = float(result.floor_proposal) + msg = ( + f"step control asked for {proposed:.3e} m, below the floor dz_min =" + f" {self._policy.dz_min:.3e} m; the tolerance cannot be met here" + ) + raise ConvergenceError(msg) + if reason == _ERROR: + message = str(result.message) + category = int(result.category) + if category == _CONVERGENCE: + raise ConvergenceError(message) + if category == _VALUE: + raise ValueError(message) + raise BackendError(f"julia execution failed: {message}") diff --git a/src/solprop/backends/julia/_runtime.py b/src/solprop/backends/julia/_runtime.py new file mode 100644 index 000000000..77a103df1 --- /dev/null +++ b/src/solprop/backends/julia/_runtime.py @@ -0,0 +1,204 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Load the source checkout's private Julia runtime only on explicit selection.""" + +import functools +import hashlib +import os +import sys +from pathlib import Path +from typing import Any + +from solprop.exceptions import BackendError + +VERSION = "1.13.3" +"""The Julia release the experiment's manifest is resolved with.""" + + +def thread_limit(name: str, default: int = 1) -> int: + """Read a positive thread-pool limit from an environment variable. + + Parameters + ---------- + name : str + Environment variable to read. + default : int, optional + Limit when the variable is absent. + + Returns + ------- + int + Positive thread count. + + Raises + ------ + BackendError + If the value is not a positive integer. + """ + try: + value = int(os.environ.get(name, str(default))) + if value < 1: + raise ValueError(name) + except ValueError as exc: + raise BackendError(f"{name} must be a positive integer") from exc + return value + + +def call_julia(function: Any, *args: object, nogil: bool = False) -> Any: + """Translate bridge failures at the dynamic JuliaCall boundary. + + Parameters + ---------- + function : object + JuliaCall function wrapper. + *args : object + Arguments accepted by the Julia function. + nogil : bool, optional + Release the GIL only for pure Julia numerical work. + + Returns + ------- + object + Converted result or opaque Julia handle. + + Raises + ------ + BackendError + If Julia or the bridge raises an exception; the cause is retained. + """ + try: + return function._jl_call_nogil(*args) if nogil else function(*args) + except Exception as exc: + raise BackendError(f"julia execution failed: {exc}") from exc + + +# JuliaCall exposes dynamically compiled Julia modules, so Any is confined to its +# boundary. Numerical arrays are converted to owned NumPy arrays by the adapter. +_GPU_PACKAGES = {"cuda": "CUDA", "rocm": "AMDGPU", "metal": "Metal"} +"""Each GPU device's Julia package, loaded before the engine.""" + + +@functools.cache +def runtime() -> Any: + """Load the experimental Julia module from this source checkout. + + ``SOLPROP_JULIA_EXE`` names the Julia 1.13 executable (default: the one + ``julia/bootstrap.py`` downloads), ``SOLPROP_JULIA_DEPOT`` its package depot + (default ``.julia-depot``) and ``SOLPROP_JULIA_ROOT`` the checkout (`checkout`). + ``SOLPROP_JULIA_DEVICE=cuda`` (``rocm``, ``metal``) loads the CUDA (AMDGPU, Metal) + environment, + so that the engine's GPU extension is available. + + Returns + ------- + object + JuliaCall's dynamically compiled module wrapper. + + Raises + ------ + BackendError + If the runtime or Julia project has not been prepared. + """ + root = checkout() + if "juliacall" in sys.modules: + raise BackendError( + "julia requires a fresh Python process: JuliaCall was already initialized" + ) + executable = Path( + os.environ.get( + "SOLPROP_JULIA_EXE", str(root / f".julia-runtime/julia-{VERSION}/bin/julia") + ) + ) + project = root / "julia" + if not executable.is_file() or not (project / "Manifest.toml").is_file(): + raise BackendError( + "julia requires a source checkout with a prepared Julia 1.13 runtime; " + "follow julia/README.md" + ) + device = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") + if device not in {"cpu", *_GPU_PACKAGES}: + raise BackendError("SOLPROP_JULIA_DEVICE must be cpu, cuda, rocm or metal") + # A GPU run's environment adds CUDA.jl or AMDGPU.jl to the engine's, resolved + # with it, so that a CPU run never resolves or loads the GPU packages. + if device != "cpu": + project = project / device + settings = { + "PYTHON_JULIACALL_EXE": str(executable), + "PYTHON_JULIACALL_PROJECT": str(project), + "PYTHON_JULIACALL_STARTUP_FILE": "no", + "PYTHON_JULIACALL_HANDLE_SIGNALS": "yes", + "PYTHON_JULIACALL_THREADS": str(thread_limit("SOLPROP_JULIA_THREADS")), + "JULIA_DEPOT_PATH": os.environ.get( + "SOLPROP_JULIA_DEPOT", str(root / ".julia-depot") + ), + "JULIA_CONDAPKG_BACKEND": "Null", + } + settings["JULIA_LOAD_PATH"] = "@:@stdlib" + # The experiment deliberately owns one Julia runtime per Python process. + for name, value in settings.items(): + if name in os.environ and os.environ[name] != value: + raise BackendError(f"julia runtime conflicts with {name}") + os.environ[name] = value + import juliacall # noqa: PLC0415 - Julia must never initialize on package import + + module = juliacall.newmodule("SolpropBackend") + if device != "cpu": + # The GPU package first, so that SolpropJulia loads with its extension. + call_julia(module.seval, f"using {_GPU_PACKAGES[device]}") + digest = source_digest() + call_julia(module.seval, "using SolpropJulia") + module.SolpropJulia.record_digest(digest) + return module.SolpropJulia + + +def checkout() -> Path: + """Return the source checkout whose ``julia/`` project the engine runs. + + ``SOLPROP_JULIA_ROOT`` names it for an installed (non-editable) solprop; by + default it is the checkout this module was imported from. + + Returns + ------- + pathlib.Path + The checkout's root directory. + """ + named = os.environ.get("SOLPROP_JULIA_ROOT") + return Path(named) if named else Path(__file__).resolve().parents[4] + + +def source_digest() -> str: + """Return a SHA-256 over the Julia sources, the manifest and this adapter. + + The experiment's counterpart of a native build's source digest: it names exactly + what a timing ran, and the engine refuses to run if its loaded module's digest + differs from the files on disk. + + Returns + ------- + str + Hexadecimal digest. + """ + root = checkout() + paths = sorted( + [ + *(root / "julia/src").rglob("*.jl"), + *(root / "julia/ext").rglob("*.jl"), + root / "julia/Project.toml", + root / "julia/Manifest.toml", + root / "julia/cuda/Project.toml", + root / "julia/cuda/Manifest.toml", + root / "julia/rocm/Project.toml", + root / "julia/rocm/Manifest.toml", + root / "julia/metal/Project.toml", + root / "julia/metal/Manifest.toml", + root / "julia/metal/LocalPreferences.toml", + ] + ) + adapter = sorted(Path(__file__).parent.glob("*.py")) + digest = hashlib.sha256() + for path in [*paths, *adapter]: + if path.is_file(): + digest.update(path.name.encode()) + digest.update(path.read_bytes()) + return digest.hexdigest() diff --git a/src/solprop/backends/registry.py b/src/solprop/backends/registry.py index 46595d192..ebc752fb6 100644 --- a/src/solprop/backends/registry.py +++ b/src/solprop/backends/registry.py @@ -83,6 +83,8 @@ class BackendEntry: "native": BackendEntry(requires=("solprop_native",), extras=()), # Apple-silicon GPUs through MLX, single precision only (SEP 33). "mlx": BackendEntry(requires=("mlx",), extras=("mlx",)), + # The Julia experiment: CPU, or NVIDIA GPU with SOLPROP_JULIA_DEVICE=cuda. + "julia": BackendEntry(requires=("juliacall",), extras=("julia",)), } """The backends this package knows, by name.""" @@ -587,6 +589,14 @@ def select_batch(owners: Sequence[Backend]) -> BatchBackend: return cast( BatchBackend, NativeBatchBackend(cast(Sequence[NativeBackend], owners)) ) + if name == "julia": + # The Julia experiment's members each step their own engine; the generic + # runner keeps them in lockstep. + from solprop.backends.batch import ( # noqa: PLC0415 - lazy backend + LockstepRunner, + ) + + return LockstepRunner(cast("Sequence[StepDriver[object]]", owners)) raise BackendError(f"Batch has no runner for backend {name!r}") @@ -683,4 +693,8 @@ def _construct( from solprop.backends.mlx_gpu.backend import MlxBackend # noqa: PLC0415 return MlxBackend(problem, grid=grid, modes=modes, profiles=profiles) + if name == "julia": # pragma: no cover - needs the Julia experiment's runtime + from solprop.backends.julia import JuliaBackend # noqa: PLC0415 + + return JuliaBackend(problem, grid=grid, modes=modes, profiles=profiles) raise AssertionError(f"unhandled backend registry entry {name!r}") diff --git a/src/solprop/driver/simulation.py b/src/solprop/driver/simulation.py index 0ab4efdf4..720d74473 100644 --- a/src/solprop/driver/simulation.py +++ b/src/solprop/driver/simulation.py @@ -1316,7 +1316,7 @@ def _stepper_record(settings: StepperSettings) -> StepperRecord: ) -LOW_STORAGE_BACKENDS = ("native", "numpy_ref") +LOW_STORAGE_BACKENDS = ("native", "numpy_ref", "julia") """The backends that execute :class:`~solprop.stepper.low_storage.LowStorageRungeKutta`. ``numpy_ref`` from SEP 24's phase 1 and solprop-native from phase 3, on every route the @@ -1395,10 +1395,10 @@ def _admit_integrator(integrator: Multistep, backend: str) -> None: DriverError Naming the conflict and the Runge-Kutta march every backend executes. """ - if backend not in ("auto", "numpy_ref", "native", "mlx"): + if backend not in ("auto", "numpy_ref", "native", "mlx", "julia"): msg = ( - f"the {integrator.name} integrator is implemented on numpy_ref, native " - f"and mlx only, and backend {backend!r} would step the problem with its " + f"the {integrator.name} integrator is implemented on numpy_ref, native, " + f"mlx and julia only, and backend {backend!r} would step the problem with its " "Runge-Kutta march; pass one of those or 'auto', or " "integrator=RungeKutta()" ) diff --git a/src/solprop/translate/precision.py b/src/solprop/translate/precision.py index 250a13ae3..79e2cf3ed 100644 --- a/src/solprop/translate/precision.py +++ b/src/solprop/translate/precision.py @@ -82,7 +82,7 @@ is admitted. """ -SINGLE_PRECISION_BACKENDS: tuple[str, ...] = ("numpy_ref", "mlx") +SINGLE_PRECISION_BACKENDS: tuple[str, ...] = ("numpy_ref", "mlx", "julia") """The backends that admit ``precision="single"``. ``numpy_ref`` is the single-precision oracle (SEP 33 phase 1) and ``mlx`` the Apple-GPU diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py new file mode 100644 index 000000000..38a2b6bcf --- /dev/null +++ b/tests/backends/test_julia.py @@ -0,0 +1,1189 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""The Julia backend experiment against the NumPy oracle, on short benchmark windows. + +Optional: skipped unless ``solprop[julia]`` is installed and ``julia/bootstrap.py`` has +prepared the runtime. ``SOLPROP_JULIA_DEVICE=cuda`` runs the same tests on an NVIDIA GPU +(``pytest -m gpu``). Every kernel body is checked to be one a GPU could take +(``SOLPROP_JULIA_CHECK``), so that a CPU run catches what would fail on a device. +""" + +import dataclasses +import importlib.util +import os + +import numpy as np +import pytest +from benchmarks.builders import build +from benchmarks.registry import CASES + +from solprop.backends import select +from solprop.exceptions import BackendError + +os.environ.setdefault("SOLPROP_JULIA_CHECK", "1") +# Bounds checked: an @inbounds index slip raises here instead of corrupting memory. +os.environ.setdefault("PYTHON_JULIACALL_CHECK_BOUNDS", "yes") +DEVICE = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") +pytestmark = [pytest.mark.medium] + ([pytest.mark.gpu] if DEVICE != "cpu" else []) +# An Apple GPU has no binary64: on Metal only the binary32 tests run, with the +# operator's exponents and the Adams flow in double-float (julia/src/dfloat.jl). +binary64 = pytest.mark.skipif(DEVICE == "metal", reason="Apple GPUs have no binary64") +# The wide types a binary32 run can form its exponents in on this device. +WIDE = ["df32"] if DEVICE == "metal" else ["binary64", "df32"] + + +@pytest.fixture(scope="module") +def runtime(): + """Start the runtime once per worker process, or skip without one.""" + if importlib.util.find_spec("juliacall") is None: + pytest.skip("solprop[julia] is not installed") + from solprop.backends.julia._runtime import runtime as start # noqa: PLC0415 + + try: + return start() + except BackendError as exc: + pytest.skip(f"the Julia runtime is not prepared: {exc}") + + +# (case, stepper, fraction): each a few steps of a focus route (docs/guide/performance/ +# julia.md). The fractions keep the NumPy oracle to seconds. +WINDOWS = [ + ("rdw", "rk", 0.002), + ("rdw", "default", 0.002), + ("argon_blueshift", "default", 0.002), + ("h2_raman_6ps", "default", 0.0005), + ("radial_filament_256", "default", 0.002), + ("line", "default", 0.005), + # Free space on the exponential Adams march: past its start-up steps. + ("line", "multistep", 0.02), + ("kerr_beam_192", "default", 1.0), +] + + +# Statistics that measure rounding: the quadrature's error estimate and the plasma +# column's work balance. +ROUNDING_ESTIMATES = frozenset(("quadrature_error", "plasma_work_defect")) + + +def _run(name, configuration): + """Propagate a window on one backend; return its field, steps and statistics.""" + simulation = build(configuration | {"backend": name}) + problem = simulation.translate() + engine = select( + name, + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(float(configuration["stop"])) + observation = engine.observe(field=True) + steps = (observation.n_steps, observation.n_rejected) + statistics = engine.stats(problem.stats_spec) + engine.close() + return observation.field, steps, statistics + + +# The Cartesian beam's fused silica is evaluated past Malitson's range, by design of the +# benchmark case; the warning says so and is not this test's subject. +@binary64 +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@pytest.mark.parametrize(("case", "stepper", "fraction"), WINDOWS) +def test_julia_matches_the_reference(runtime, case, stepper, fraction): + """Same steps, and the same field to rounding, as numpy_ref on the same contract.""" + del runtime + configuration = CASES[case].configuration( + stepper, 2, "julia", fraction=fraction, noise="none" + ) + field, steps, statistics = _run("julia", configuration) + reference, reference_steps, reference_statistics = _run("numpy_ref", configuration) + assert steps == reference_steps + # The engine forms the Poynting set's transforms and the populations itself: each + # statistic to rounding of its own largest value (a spectrum's tails are rounding). + assert set(statistics) == set(reference_statistics) + for name, value in reference_statistics.items(): + if name in ROUNDING_ESTIMATES: + # A difference of nearly equal sums, at their rounding here (a work defect + # of 1e-13 to 1e-12): two orders of summation agree on its order only. + ours, theirs = float(statistics[name][0]), float(value[0]) + assert ours == theirs or 0.5 <= ours / theirs <= 2.0, (name, ours, theirs) + continue + largest = float(np.max(np.abs(value), initial=0.0)) + np.testing.assert_allclose( + statistics[name], value, rtol=1e-9, atol=1e-9 * largest, err_msg=name + ) + # Matched discrete methods on one step sequence: the fields differ by the rounding + # of their transforms and sums, which the native/julia A/B measures at <= 1e-13 + # over these windows; 1e-10 leaves three orders for longer accumulation and is + # still far below the controller's 1e-6 relative tolerance. + scale = float(np.linalg.norm(reference)) + assert scale > 0 + assert float(np.linalg.norm(field - reference)) <= 1e-10 * scale + + +@binary64 +def _fixed_capillary(backend, *, integrator=None, fixed=True, **extra): + """A short ionising capillary, on 16 fixed steps (a batch runs a fixed schedule) or + adaptive.""" + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + + length = 0.004 + schedule = FixedSchedule.uniform(0.0, length, length / 16) if fixed else None + return Simulation.from_capillary( + 50e-6, + length, + "Ar", + 1.0, + wavelength=800e-9, + wavelength_limits=(150e-9, 3e-6), + trange=300e-15, + fwhm=10e-15, + energy=60e-6, + n_save=2, + backend=backend, + integrator=RungeKutta() if integrator is None else integrator, + schedule=schedule, + absorber_scheme="split_step", + noise=None, + **extra, + ) + + +@binary64 +def test_julia_modal_low_storage_matches_the_reference(runtime): + """RK4IP on a capillary (a modal route) replays the reference's schedule.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.stepper import LowStorageRungeKutta # noqa: PLC0415 + + stop, fields = 0.004, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + simulation = _fixed_capillary(name, integrator=LowStorageRungeKutta()) + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(stop) + fields[name] = engine.observe(field=True).field + scale = float(np.linalg.norm(fields["numpy_ref"])) + assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale + + +# The band reaches below O2's qualified dispersion range; the warning says so and is +# not this test's subject. +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@binary64 +def test_julia_two_raman_components_match_the_reference(runtime): + """Two Raman components (air's, split into an N2 and an O2 half) sum into the + engine's one kernel and match the reference's two convolutions.""" + del runtime + import dataclasses # noqa: PLC0415 + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + from solprop.translate.problem import Flags # noqa: PLC0415 + + length = 0.004 + simulation = Simulation.from_capillary( + 50e-6, + length, + {"N2": 0.79, "O2": 0.21}, + 1.0, + wavelength=800e-9, + wavelength_limits=(200e-9, 3e-6), + trange=300e-15, + fwhm=10e-15, + energy=40e-6, + n_save=2, + backend="numpy_ref", + plasma=False, + raman=True, + noise=None, + integrator=RungeKutta(), + absorber_scheme="split_step", + schedule=FixedSchedule.uniform(0.0, length, length / 16), + ) + problem = simulation.translate() + (term,) = problem.responses.raman_terms + terms = tuple( + dataclasses.replace(term, fraction=term.fraction / 2, label=label) + for label in ("N2", "O2") + ) + responses = dataclasses.replace(problem.responses, raman_terms=terms) + problem = dataclasses.replace( + problem, + responses=responses, + flags=Flags.from_content( + shape=problem.shape, + linear=problem.linear, + transform=problem.transform, + responses=responses, + initial=problem.initial, + ), + ) + fields = {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + engine = select( + name, + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + cleanup.callback(engine.close) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(length) + fields[name] = engine.observe(field=True).field + scale = float(np.linalg.norm(fields["numpy_ref"])) + assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale + + +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@pytest.mark.filterwarnings("ignore::solprop.exceptions.GasFlowWarning") +@binary64 +def test_julia_taper_matches_the_reference(runtime): + """A 20 % radius taper with a pressure gradient: the synthesis scaled by the taper, + the projection by its reciprocal, on ten fixed steps (the native test's case).""" + del runtime + from dataclasses import replace # noqa: PLC0415 + + from solprop.boundaries import absorber # noqa: PLC0415 + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.profiles import Linear # noqa: PLC0415 + from solprop.stepper import FixedSchedule # noqa: PLC0415 + + length = 0.1 + + def field(backend): + simulation = Simulation.from_capillary( + Linear(100e-6, 80e-6, length), + length, + "Ar", + (5.0, 0.2), + wavelength=800e-9, + fwhm=30e-15, + energy=10e-6, + wavelength_limits=(300e-9, 2e-6), + trange=400e-15, + noise=None, + vacuum_end="floor", + plasma=False, + n_save=3, + backend=backend, + schedule=FixedSchedule(np.full(10, length / 10)), + ) + simulation.settings = replace( + simulation.settings, + absorber=absorber(simulation.grid, boundary_length=10.0), + boundary_check=None, + ) + return np.asarray(simulation.run()["field"])[-1] + + expected, ours = field("numpy_ref"), field("julia") + scale = float(np.linalg.norm(expected)) + assert float(np.linalg.norm(ours - expected)) <= 1e-10 * scale + + +@binary64 +def test_julia_window_statistics_match_the_reference(runtime): + """The energy and peak power in a band and the zero-dispersion wavelength, which the + shared host functions form from the state, as the reference forms them.""" + del runtime + import dataclasses # noqa: PLC0415 + + names = ("energy_window", "peak_power_window", "zdw") + configuration = CASES["rdw"].configuration( + "default", 2, "julia", fraction=0.002, noise="none" + ) + values = {} + for name in ("numpy_ref", "julia"): + simulation = build(configuration | {"backend": name}) + problem = simulation.translate() + spec = dataclasses.replace( + problem.stats_spec, names=names, energy_windows=np.array([[1.5e15, 3.0e15]]) + ) + engine = select( + name, + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(float(configuration["stop"])) + values[name] = engine.stats(spec) + engine.close() + for statistic in names: + expected = np.asarray(values["numpy_ref"][statistic]) + largest = float(np.max(np.abs(expected), initial=0.0)) + np.testing.assert_allclose( + values["julia"][statistic], + expected, + rtol=1e-9, + atol=1e-9 * largest, + err_msg=statistic, + ) + + +@pytest.mark.parametrize("thg", [False, True]) +@binary64 +def test_julia_resolved_envelopes_match_the_reference(runtime, thg): + """Four resolved modes on the envelope grid, with and without the third harmonic's + carrier term.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + + length, fields = 0.004, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + simulation = Simulation.from_capillary( + 50e-6, + length, + "Ar", + 1.0, + wavelength=800e-9, + wavelength_limits=(150e-9, 3e-6), + trange=300e-15, + fwhm=10e-15, + energy=60e-6, + n_save=2, + backend=name, + integrator=RungeKutta(), + schedule=FixedSchedule.uniform(0.0, length, length / 16), + absorber_scheme="split_step", + noise=None, + envelope=True, + plasma=False, + thg=thg, + modes=4, + ) + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(length) + fields[name] = engine.observe(field=True).field + scale = float(np.linalg.norm(fields["numpy_ref"])) + assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale + + +@binary64 +def test_julia_radial_envelope_matches_the_reference(runtime): + """A self-focusing Kerr beam on the radial route's envelope grid.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from legacy_geometry import LEGACY_GRID, bare_absorber # noqa: PLC0415 + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.driver.simulation import SimulationSettings # noqa: PLC0415 + from solprop.grid import EnvelopeGrid, RadialGrid # noqa: PLC0415 + from solprop.nonlinear.responses import KerrResponse # noqa: PLC0415 + from solprop.pulses import GaussianPulse, SpatialPulse # noqa: PLC0415 + from solprop.spatial import SpatialMedium # noqa: PLC0415 + from solprop.stepper import FixedSchedule, PIController, RungeKutta # noqa: PLC0415 + + length, fields = 0.1, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + grid = EnvelopeGrid.from_limits( + length, 800e-9, (600e-9, 1.2e-6), 150e-15, thg=False, **LEGACY_GRID + ) + settings = SimulationSettings( + controller=PIController(rtol=1e-6, atol=0.0), + save_planes=[length], + dz_max=length, + dz_init=length / 10, + schedule=FixedSchedule.uniform(0.0, length, length / 10), + backend=name, + integrator=RungeKutta(), + absorber=bare_absorber(grid), + ) + pulse = SpatialPulse( + GaussianPulse(wavelength=800e-9, fwhm=50e-15, energy=3e-4), 300e-6 + ) + simulation = Simulation.from_radial( + grid, + RadialGrid(2e-3, 32), + SpatialMedium(), + [KerrResponse(1e-25, thg=False)], + pulse, + settings=settings, + noise=None, + ) + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(length) + fields[name] = engine.observe(field=True).field + scale = float(np.linalg.norm(fields["numpy_ref"])) + assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale + + +@pytest.mark.parametrize( + ("grid_kind", "thg"), [("envelope", False), ("field", True), ("field", False)] +) +@binary64 +def test_julia_free_space_raman_matches_the_reference(runtime, grid_kind, thg): + """Kerr and one Raman term on a line (free space), on the envelope grid and on the + field grid with and without the third harmonic, as the reference evaluates them.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + from functools import partial # noqa: PLC0415 + + from backends.test_radial_nonlinear import LENGTH, make_problem # noqa: PLC0415 + from solprop.grid import EnvelopeGrid, FieldGrid, LineGrid # noqa: PLC0415 + from solprop.nonlinear.raman import ( # noqa: PLC0415 + DampedOscillator, + RamanResponse, + undamped_dephasing, + ) + from solprop.nonlinear.responses import KerrResponse # noqa: PLC0415 + from solprop.pulses import GaussianPulse, SpatialPulse # noqa: PLC0415 + from solprop.spatial import SpatialMedium # noqa: PLC0415 + + constructor = ( + FieldGrid.from_limits + if grid_kind == "field" + else partial(EnvelopeGrid.from_limits, thg=False) + ) + grid = constructor(LENGTH, 800e-9, (600e-9, 1.2e-6), 150e-15) + space = LineGrid(4e-4, 24) + pulse = SpatialPulse( + GaussianPulse(wavelength=800e-9, fwhm=30e-15, energy=1e-3), 80e-6, jones=(1,) + ) + responses = [ + KerrResponse(1e-25, thg=thg), + RamanResponse((DampedOscillator(1e-8, 2e14, undamped_dephasing()),), thg=thg), + ] + problem = make_problem( + grid, + space, + pulse.build(grid, space, medium=SpatialMedium()), + responses, + density=1.0, + ) + observed = {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + engine = select(name, problem, grid=grid) + cleanup.callback(engine.close) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(LENGTH) + observation = engine.observe(field=True) + observed[name] = (observation.field, observation.n_steps) + (field, steps), (expected, expected_steps) = ( + observed["julia"], + observed["numpy_ref"], + ) + assert steps == expected_steps + scale = float(np.linalg.norm(expected)) + assert float(np.linalg.norm(field - expected)) <= 1e-10 * scale + + +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@binary64 +def test_julia_two_plasma_channels_match_the_reference(runtime): + """Air's two ionising species: each channel's rates and currents, summed, and each + species' populations, as the reference forms them.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + + length, observed = 0.004, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + simulation = Simulation.from_capillary( + 50e-6, + length, + {"N2": 0.79, "O2": 0.21}, + 1.0, + wavelength=800e-9, + wavelength_limits=(200e-9, 3e-6), + trange=300e-15, + fwhm=10e-15, + energy=60e-6, + n_save=2, + backend=name, + integrator=RungeKutta(), + schedule=FixedSchedule.uniform(0.0, length, length / 16), + absorber_scheme="split_step", + noise=None, + raman=False, + ) + problem = simulation.translate() + assert len(problem.responses.plasma_channels) == 2 + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(length) + observed[name] = ( + engine.observe(field=True).field, + engine.stats(problem.stats_spec), + ) + (field, statistics), (expected, reference) = ( + observed["julia"], + observed["numpy_ref"], + ) + scale = float(np.linalg.norm(expected)) + assert float(np.linalg.norm(field - expected)) <= 1e-10 * scale + for statistic, value in reference.items(): + if statistic in ROUNDING_ESTIMATES or statistic not in statistics: + continue + largest = float(np.max(np.abs(value), initial=0.0)) + np.testing.assert_allclose( + statistics[statistic], + value, + rtol=1e-9, + atol=1e-9 * largest, + err_msg=statistic, + ) + + +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@pytest.mark.filterwarnings("ignore::solprop.exceptions.GasFlowWarning") +@binary64 +def test_julia_varying_raman_matches_the_reference(runtime): + """A hydrogen gradient: the Raman density and decay rates vary along the guide, and + the engine rebuilds its kernel at each stage as the reference does.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.physdata.selection import MaterialSelection # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + + length, fields = 0.05, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + simulation = Simulation.from_capillary( + 75e-6, + length, + "H2", + (3.0, 0.5), + wavelength=800e-9, + wavelength_limits=(300e-9, 3e-6), + trange=1e-12, + fwhm=30e-15, + energy=50e-6, + n_save=2, + backend=name, + integrator=RungeKutta(), + schedule=FixedSchedule.uniform(0.0, length, length / 16), + absorber_scheme="split_step", + noise=None, + plasma=False, + raman=True, + # The lines' density shift held at the reference density (the seam + # cannot follow it along a gradient). + materials=MaterialSelection(raman_shift="reference-density"), + ) + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(length) + fields[name] = engine.observe(field=True).field + scale = float(np.linalg.norm(fields["numpy_ref"])) + assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale + + +ENVELOPE_PLASMA_STATISTICS = ( + "electron_density", + "peak_ionisation_rate", + "species_ionisation", +) + + +def _envelope_plasma( + name, waveguide, precision="double", energy=4e-4, names=ENVELOPE_PLASMA_STATISTICS +): + """Argon's envelope plasma (preionised 10 %, ionising) on four fixed steps: a + resolved capillary or a mode-averaged waveguide. Return its field and statistics.""" + from contextlib import ExitStack # noqa: PLC0415 + + from rate_oracles import adk_oracle # noqa: PLC0415 + from solprop.boundaries import absorber # noqa: PLC0415 + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.modes import MarcatiliMode # noqa: PLC0415 + from solprop.stats import StatsSpec # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + + length = 8e-6 + options = { + "wavelength": 800e-9, + "wavelength_limits": (500e-9, 1.2e-6), + "trange": 80e-15, + "fwhm": 20e-15, + "energy": energy, + "envelope": True, + "plasma": adk_oracle("Ar"), + "preionisation": 0.1, + "raman": False, + "kerr": True, + "noise": None, + "schedule": FixedSchedule.uniform(0.0, length, length / 4), + "save_planes": [length / 2, length], + "integrator": RungeKutta(), + "stats": StatsSpec(names=names), + "precision": precision, + "backend": name, + } + if waveguide: + simulation = Simulation.from_waveguide( + [MarcatiliMode(125e-6, "Ar", 1.0, loss=False, cladding=1.45)], + length, + "Ar", + 1.0, + **options, + ) + else: + simulation = Simulation.from_capillary( + 125e-6, + length, + "Ar", + 1.0, + loss=False, + cladding=1.45, + n_r=4, + radial_rule="gauss", + **options, + ) + simulation.settings = dataclasses.replace( + simulation.settings, absorber=absorber(simulation.grid, boundary_length=1e-3) + ) + with ExitStack() as cleanup: + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(length) + return engine.observe(field=True).field, engine.stats( + simulation.translate().stats_spec + ) + + +@pytest.mark.parametrize("waveguide", [False, True]) +@binary64 +def test_julia_envelope_plasma_matches_the_reference(runtime, waveguide): + """The envelope plasma's field and populations are the reference's to rounding.""" + del runtime + field, statistics = _envelope_plasma("julia", waveguide) + reference, expected = _envelope_plasma("numpy_ref", waveguide) + # The rate is live: the cycle quadrature and the loss current are exercised. + assert float(np.max(expected["peak_ionisation_rate"])) > 1e9, expected + scale = float(np.linalg.norm(reference)) + assert float(np.linalg.norm(field - reference)) <= 1e-10 * scale + for name in ENVELOPE_PLASMA_STATISTICS: + np.testing.assert_allclose( + statistics[name], expected[name], rtol=1e-9, err_msg=name + ) + + +@pytest.mark.parametrize("grid_kind", ["field", "envelope"]) +@binary64 +def test_julia_on_axis_plasma_statistics_match_the_reference(runtime, grid_kind): + """The on-axis plasma statistics on a resolved capillary (no node on the axis, so + the axis row is scanned): the reference's, on the field and envelope grids.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.stats import ON_AXIS_PLASMA_STATISTICS, StatsSpec # noqa: PLC0415 + + names = ("electron_density", *ON_AXIS_PLASMA_STATISTICS) + statistics = {} + for name in ("numpy_ref", "julia"): + if grid_kind == "envelope": + _, statistics[name] = _envelope_plasma(name, False, names=names) + continue + simulation = _fixed_capillary( + name, n_r=4, radial_rule="gauss", stats=StatsSpec(names=names) + ) + with ExitStack() as cleanup: + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(0.004) + statistics[name] = engine.stats(simulation.translate().stats_spec) + expected = statistics["numpy_ref"] + assert float(np.max(expected["on_axis_peak_ionisation_rate"])) > 0 + for name in names: + np.testing.assert_allclose( + statistics["julia"][name], expected[name], rtol=1e-9, err_msg=name + ) + + +@pytest.mark.parametrize("wide", WIDE) +@pytest.mark.parametrize("waveguide", [False, True]) +def test_julia_single_precision_envelope_plasma(runtime, monkeypatch, waveguide, wide): + """Binary32's envelope plasma (its cycle sums compensated) tracks the binary32 + reference as the other windows do, and its populations within the same 1e-4.""" + del runtime + monkeypatch.setenv("SOLPROP_JULIA_WIDE", wide) + field, statistics = _envelope_plasma("julia", waveguide, "single") + reference, expected = _envelope_plasma("numpy_ref", waveguide, "single") + scale = float(np.linalg.norm(reference)) + assert float(np.linalg.norm(field - reference)) <= 1e-4 * scale + for name in ENVELOPE_PLASMA_STATISTICS: + np.testing.assert_allclose( + statistics[name], expected[name], rtol=1e-4, err_msg=name + ) + + +@binary64 +def test_julia_tsit5_matches_the_reference(runtime): + """An adaptive TSIT5 window takes the reference's steps and field.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.stepper import RungeKutta # noqa: PLC0415 + from solprop.stepper.tableau import TSIT5 # noqa: PLC0415 + + stop, observed = 0.004, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + simulation = _fixed_capillary( + name, integrator=RungeKutta(TSIT5), fixed=False + ) + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(stop) + observation = engine.observe(field=True) + observed[name] = ( + observation.field, + observation.n_steps, + observation.n_rejected, + ) + field, steps, rejected = observed["julia"] + expected, expected_steps, expected_rejected = observed["numpy_ref"] + assert (steps, rejected) == (expected_steps, expected_rejected) + scale = float(np.linalg.norm(expected)) + assert float(np.linalg.norm(field - expected)) <= 1e-10 * scale + + +def _loaded(simulation, name, cleanup): + """The simulation's backend, its launch loaded.""" + problem = simulation.translate() + engine = select( + name, + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + cleanup.callback(engine.close) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + return engine + + +@binary64 +def test_julia_batch_members_are_their_solo_runs(runtime): + """Lockstep members (`select_batch`) match their solo runs and the reference.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.backends.registry import select_batch # noqa: PLC0415 + + stop = 0.004 + with ExitStack() as cleanup: + reference = _loaded(_fixed_capillary("numpy_ref"), "numpy_ref", cleanup) + reference.propagate_to(stop) + expected = reference.observe(field=True).field + members = [ + _loaded(_fixed_capillary("julia"), "julia", cleanup) for _ in range(2) + ] + runner = select_batch(members) + runner.propagate_to(stop) + fields = [member.field for member in runner.observe_members()] + scale = float(np.linalg.norm(expected)) + for field in fields: + assert float(np.linalg.norm(field - expected)) <= 1e-10 * scale + + +def test_julia_reports_its_engine(runtime): + """Metadata names the runtime and the sources; the ledger counts owned arrays.""" + del runtime + # Metal has binary32 only: a complex sample is 8 bytes there, 16 elsewhere. + single = DEVICE == "metal" + configuration = CASES["rdw"].configuration( + "rk", 1, "julia32" if single else "julia", fraction=0.001 + ) + simulation = build(configuration | {"noise": "none"}) + problem = simulation.translate() + engine = select("julia", problem, grid=simulation.grid, modes=simulation.modes) + metadata = engine.metadata() + assert metadata["experimental"] is True + assert len(metadata["julia_source_digest"]) == 64 + assert metadata["device"].startswith(DEVICE) + ledger = engine.memory_ledger() + width = 8 if single else 16 + assert ledger["work.y"] == width * problem.shape[1] * problem.shape[3] + engine.close() + + +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@pytest.mark.parametrize("wide", WIDE) +@pytest.mark.parametrize(("case", "stepper", "fraction"), WINDOWS[:7]) +def test_julia_single_precision_tracks_the_reference( + runtime, monkeypatch, case, stepper, fraction, wide +): + """Binary32 (SEP 33) agrees with the binary32 reference on the same contract. + + A single-precision run's grid is its own, so the reference is numpy_ref's binary32 + path, not the binary64 run. The steps may differ: binary32's error estimate is + noisier near rtol's floor. The operator's exponents and the Adams flow are formed + in binary64 or in double-float (``SOLPROP_JULIA_WIDE``), rounded once either way. + """ + del runtime + monkeypatch.setenv("SOLPROP_JULIA_WIDE", wide) + configuration = CASES[case].configuration( + stepper, 2, "julia", fraction=fraction, noise="none" + ) | {"precision": "single"} + field, _, _ = _run("julia", configuration) + reference, _, _ = _run("numpy_ref", configuration) + # SEP 33's whole-run field envelope is 1e-3; over these few steps two binary32 + # implementations differ by their rounding, ~1e-6 (PR #543's records), so 1e-4 + # holds two orders in hand and still catches a mis-scaled response (O(1)). + scale = float(np.linalg.norm(reference)) + assert float(np.linalg.norm(field - reference)) <= 1e-4 * scale + + +def test_julia_double_float_phi_is_binary64s(runtime): + """The double-float phi functions agree with the binary64 ones to well inside + binary32's rounding, across the series and recurrence branches and a long phase. + + The pair holds about 2^-48; the recurrence past |x| = 3 amplifies an error by up to + about k! / |x|^k (4e-13 relative at order 9 just past the join), and the phase's + reduction keeps about 2^-48 of the phase. 2^-36 bounds both and is still 2^12 + inside the binary32 rounding each value then takes. + """ + generator = np.random.default_rng(5) + radii = np.concatenate([10.0 ** generator.uniform(-6, 0.5, 40), [2.9, 3.1, 30.0]]) + angles = generator.uniform(-np.pi, np.pi, radii.size) + points = [*(radii * np.exp(1j * angles)), -40 + 2e3j, -1e-3 + 1e4j, 0.0] + for order in (1, 3, 6, 9): + for x in points: + exact = np.asarray(runtime.phi_snapshot(complex(x), order)) + pair = np.asarray(runtime.phi_snapshot_df(complex(x), order)) + bound = 2.0**-36 * max(1.0, abs(x.imag)) * np.abs(exact) + 1e-300 + np.testing.assert_array_less( + np.abs(pair - exact), bound, err_msg=f"{x} {order}" + ) + + +def test_julia_double_float_propagators_round_once(runtime): + """exp(+-z) by the double-float pair is within a few binary32 ulps of binary64's, + for phases up to 1e6 rad (the mlx backend's measured bound is 5 u).""" + generator = np.random.default_rng(7) + re = generator.uniform(-20, 5, 2000) + im = np.concatenate( + [generator.uniform(-10, 10, 1000), generator.uniform(-1e6, 1e6, 1000)] + ) + for z in re + 1j * im: + forward, back = runtime.exp_pair_snapshot_df(complex(z)) + for value, exact in ((forward, np.exp(z)), (back, np.exp(-z))): + assert abs(value - exact) <= 8 * 2.0**-24 * abs(exact), (z, value, exact) + + +@binary64 +def test_julia_poynting_statistics_match_the_host(runtime): + """The engine's analytic signals give the shared host function's statistics.""" + del runtime + from solprop.stats import _poynting_statistics # noqa: PLC0415 + + configuration = CASES["rdw"].configuration( + "default", 2, "julia", fraction=0.002, noise="none" + ) + simulation = build(configuration) + problem = simulation.translate() + engine = select( + "julia", + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(float(configuration["stop"])) + state = engine.observe(field=True).field[0] + axis = engine._on_axis_synthesis(simulation.modes) + spec = problem.stats_spec + ours = engine._poynting(spec, simulation.grid, state, axis) + host = _poynting_statistics(spec, simulation.grid, state, engine._weight, axis) + assert set(ours) == set(host) + for name, value in host.items(): + # The same transforms in another library and order: rounding of the analytic + # signals' sums, far below the 1e-10 the fields are held to. + np.testing.assert_allclose(ours[name], value, rtol=1e-11, atol=0, err_msg=name) + engine.close() + + +@binary64 +def test_julia_helpers_are_the_python_forms_bit_for_bit(runtime): + """The record's Chebyshev rows and Adams basis equal PLAIN's to the last bit.""" + del runtime + from solprop._helpers import PLAIN # noqa: PLC0415 + from solprop.backends.julia._helpers import JULIA # noqa: PLC0415 + + generator = np.random.default_rng(7) + edges = np.cumsum(generator.uniform(0.1, 1.0, 6)) + lower, upper = edges[0] - 1e-12, edges[-1] + 1e-12 + z = np.concatenate([edges, generator.uniform(edges[0], edges[-1], 9), [np.nan]]) + for terms in (1, 2, 3, 17): + for dtype in (np.float64, np.complex128): + c = generator.standard_normal((5, terms, 4)).astype(dtype) + if dtype == np.complex128: + c += 1j * generator.standard_normal(c.shape) + ours, theirs = np.empty((z.size, 4), dtype), np.empty((z.size, 4), dtype) + assert JULIA.points(z, edges, lower, upper, c, ours) == PLAIN.points( + z, edges, lower, upper, c, theirs + ) + np.testing.assert_array_equal(ours, theirs) + outside = np.array([edges[1], edges[-1] + 1.0]) + out = np.empty((2, 4)) + c = generator.standard_normal((5, 3, 4)) + assert JULIA.points(outside, edges, lower, upper, c, out) == 1 + nodes = np.array([0.0, -0.93, -1.81, -2.77, -3.6, -4.55, -5.4]) + for count in range(1, nodes.size + 1): + for upper, integrate in ((1.0, False), (1.0, True), (0.37, True)): + ours = JULIA.basis(np.ascontiguousarray(nodes[:count]), upper, integrate) + theirs = PLAIN.basis(np.ascontiguousarray(nodes[:count]), upper, integrate) + np.testing.assert_array_equal(ours[0], theirs[0]) + if integrate: + np.testing.assert_array_equal(ours[1], theirs[1]) + + +@binary64 +@pytest.mark.parametrize("compensated", [False, True]) +def test_julia_trial_tables_are_the_shared_ones_bit_for_bit(runtime, compensated): + """The engine's own trial tables equal backends.multistep.trial_tables'.""" + from juliacall import Main # noqa: PLC0415 + + from solprop._helpers import PLAIN # noqa: PLC0415 + from solprop.backends.multistep import trial_tables # noqa: PLC0415 + + nodes = [0.0, -0.93, -1.81, -2.77, -3.6, -4.55] + host = Main.seval( + """(configure, nodes, order, orders, compensated) -> begin + sizes = [0, 0, 0] + h = (predictor=zeros(8, 8), corrector=zeros(8, 8), defects=zeros(8, 16), + slots=zeros(Int, 8), spans=zeros(8), cpredictor=zeros(8), + ccorrector=zeros(8), cdefects=zeros(8, 8), rate=zeros(1)) + adams = (host=h, device=h, sizes=sizes, compensated=compensated) + engine = (work=(adams=adams,),) + configure(engine, nodes, order, orders, zeros(Int, 8), [0.5]) + h + end""" + ) + for order, orders in ((3, [3, 2, 4]), (4, [4, 3, 5]), (1, [1, 2])): + h = host( + runtime.configure_adams_nodes_b, + np.asarray(nodes), + order, + np.asarray(orders), + compensated, + ) + shared = trial_tables( + nodes=nodes, + order=order, + orders=orders, + compensated=compensated, + helpers=PLAIN, + ) + width, count = 1 + max(orders), len(orders) + np.testing.assert_array_equal( + np.asarray(h.predictor)[:order, :order], shared[0] + ) + np.testing.assert_array_equal( + np.asarray(h.corrector)[:width, :width], shared[1] + ) + np.testing.assert_array_equal( + np.asarray(h.defects)[:count, : 2 * width], shared[2] + ) + if compensated: + np.testing.assert_array_equal(np.asarray(h.spans)[: width - 1], shared[3]) + np.testing.assert_array_equal(np.asarray(h.cpredictor)[:order], shared[4]) + np.testing.assert_array_equal( + np.asarray(h.ccorrector)[: order + 1], shared[5] + ) + np.testing.assert_array_equal( + np.asarray(h.cdefects)[:count, :width], shared[6] + ) + + +@binary64 +def test_julia_stage_scalars_are_the_bundles_bit_for_bit(runtime): + """The engine's stage scalars, from its own tables, equal scalars_at's. + + rdw's gas fill varies along the capillary: the operator's and prefactor's + expansions, the Kerr and plasma densities (the focus cases' only varying one). + """ + del runtime + case = "rdw" + from solprop._helpers import PLAIN # noqa: PLC0415 + from solprop.translate.stage import scalars_at # noqa: PLC0415 + + configuration = CASES[case].configuration( + "default", 1, "julia", fraction=0.002, noise="none" + ) + simulation = build(configuration) + problem = simulation.translate() + engine = select("julia", problem, grid=simulation.grid, modes=simulation.modes) + assert engine._varying + span = float(configuration["stop"]) + z, dz = 0.37 * span, 0.21 * span + engine._prepare_stages(z, dz) + path = engine._engine.work.path + count = len(problem.stepper.tableau.nodes) + positions = [z] * (count - 1) + [z + dz] + bundles = scalars_at(problem, z, positions, helpers=PLAIN) + kerr = problem.responses.kerr_coefficients + expected = { + "delta": np.stack([b.phi_delta for b in bundles], axis=1), + "weights": np.stack([b.prefactor for b in bundles], axis=1), + "material": np.array( + [ + [ + 0.0 if kerr is None else kerr.coefficient * b.kerr_density, + b.plasma_densities[0] if b.plasma_densities else 0.0, + b.preionisation, + b.taper_scale, + ] + for b in bundles + ] + ).T, + } + for name, value in expected.items(): + held = np.asarray(getattr(path, name))[:, :count] + np.testing.assert_array_equal(held, value, err_msg=name) + engine.close() + + +def test_julia_vector_maths_is_within_an_ulp_or_two(runtime): + """vexp and vlog (julia/src/vmath.jl) against the C library's functions. + + Each is within one ulp of the correctly rounded value (measured against + BigFloat when written); the C library's within one more, so two bound the gap. + """ + from juliacall import Main # noqa: PLC0415 + + apply = Main.seval("(f, x) -> f.(x)") + generator = np.random.default_rng(11) + x = np.concatenate( + [-745 + 1454 * generator.random(100_000), generator.standard_normal(10_000)] + ) + ours = np.asarray(apply(runtime.vexp, x)) + np.testing.assert_array_less( + np.abs(ours - np.exp(x)), 2 * np.spacing(np.exp(x)) + 1e-320 + ) + x = np.exp(-700 + 1400 * generator.random(100_000)) + ours = np.asarray(apply(runtime.vlog, x)) + np.testing.assert_array_less( + np.abs(ours - np.log(x)), 2 * np.abs(np.spacing(np.log(x))) + ) + specials = np.asarray( + apply(runtime.vexp, np.array([np.nan, np.inf, -np.inf, 800.0])) + ) + assert np.isnan(specials[0]) + assert specials[1:].tolist() == [np.inf, 0.0, np.inf] + assert np.isnan(float(apply(runtime.vlog, np.array([np.nan]))[0])) + + +def _march(configuration, march): + """Run a window with the named march; return the field, history and ledger.""" + os.environ["SOLPROP_JULIA_MARCH"] = march + try: + simulation = build(configuration) + problem = simulation.translate() + engine = select( + "julia", + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + finally: + del os.environ["SOLPROP_JULIA_MARCH"] + assert engine._adams.native == (march == "julia") + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(float(configuration["stop"])) + field = engine.observe(field=True).field + ledger = engine._adams.ledger + record = ( + [tuple(attempt[:4]) for attempt in engine._history], + (ledger.startup, ledger.predictor, ledger.rejected, ledger.accepted_steps), + (ledger.rejected_steps, ledger.restarts, ledger.failure_restarts), + list(ledger.orders), + engine._split_removed, + None if engine._split_found is None else engine._split_found.tolist(), + ) + engine.close() + return field, record + + +@binary64 +@pytest.mark.parametrize( + ("case", "fraction"), + [ + ("rdw", 0.002), + ("argon_blueshift", 0.002), + ("ctc_reduced", 0.002), + ("radial_filament_256", 0.002), + ], +) +def test_julia_march_is_the_python_march(runtime, monkeypatch, case, fraction): + """Julia's Adams march takes the Python march's decisions on the same engine. + + The same attempts, ledger and accepted orders, the same split collar sums (radial), + and the same field bit for bit; + estimated FFT plans, since a measured plan may differ from one process to the next. + """ + del runtime + monkeypatch.setenv("SOLPROP_FFTW_PLAN", "estimate") + configuration = CASES[case].configuration( + "default", 2, "julia", fraction=fraction, noise="none" + ) + field, record = _march(configuration, "julia") + reference, reference_record = _march(configuration, "host") + assert record == reference_record + np.testing.assert_array_equal(field, reference) + + +@binary64 +@pytest.mark.filterwarnings("ignore::solprop.exceptions.BoundaryWarning") +@pytest.mark.parametrize( + ("case", "fraction"), [("radial_filament_256", 0.002), ("line", 0.005)] +) +def test_julia_first_window_compiles_nothing(runtime, case, fraction): + """After the benchmark worker's warm-up, a timed run compiles (almost) nothing. + + The warm-up propagates without a boundary monitor, so the monitor's bindings and + the split collar's march first run inside the window: each bridge type compiled + there cost up to 0.25 s of a radial window until the construction warmed them. + """ + del runtime + from benchmarks.worker import timed_run # noqa: PLC0415 + from juliacall import Main # noqa: PLC0415 + + from solprop.driver.run import field_retention # noqa: PLC0415 + + configuration = CASES[case].configuration( + "default", 2, "julia", fraction=fraction, noise="none" + ) | {"warmup": 0.02} + simulation = build(configuration) + problem = simulation.translate() + engine = select( + "julia", + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + retention = field_retention( + problem, simulation.settings.fields, simulation.settings.field_planes + ) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(configuration["warmup"] * configuration["stop"]) + engine.observe(field=True) + engine.stats(problem.stats_spec) + Main.seval("Base.cumulative_compile_timing(true)") + compiled = Main.seval("() -> Base.cumulative_compile_time_ns()[1]") + compiled() + before = compiled() + timed_run(simulation, problem, engine, retention, simulation._boundary_monitor()) + # Some tens of milliseconds of inference the compile trace does not list remain + # (about 21 on radial); a bridge type left to the window cost 50 to 250. + assert (compiled() - before) / 1e6 < 50.0 + engine.close() diff --git a/tests/backends/test_registry.py b/tests/backends/test_registry.py index a4e33c542..effeed954 100644 --- a/tests/backends/test_registry.py +++ b/tests/backends/test_registry.py @@ -186,8 +186,9 @@ def test_an_unknown_name_lists_what_is_usable(linear_problem, narrow_grid): def test_the_table_holds_the_backends_that_exist(): - """The in-tree CUDA backend is gone; mlx is SEP 33's single-precision GPU.""" - assert sorted(BACKENDS) == ["mlx", "native", "numpy_ref"] + """The in-tree CUDA backend is gone; mlx is SEP 33's single-precision GPU; julia + is the Julia backend experiment (julia/STATUS.md).""" + assert sorted(BACKENDS) == ["julia", "mlx", "native", "numpy_ref"] # The tombstone: a removed backend's name is refused wherever a request is validated. diff --git a/uv.lock b/uv.lock index 417d617ce..a9c40d9d4 100644 --- a/uv.lock +++ b/uv.lock @@ -615,6 +615,33 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, ] +[[package]] +name = "juliacall" +version = "0.9.37" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "juliapkg" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/8e/bf4fdb7bcb077747ba0031bea51023e559476c0ab7fc8ba8ea0d59a608eb/juliacall-0.9.37.tar.gz", hash = "sha256:246db2ec648cd50dcd446d02323e0b187949a2ab50e06e32fe6db1a4323eba75", size = 502805, upload-time = "2026-10-19T19:03:30.597Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/fc/97ba79312c411bb25e31ea460b7080b2da932c884086967e5d06ddf80107/juliacall-0.9.37-py3-none-any.whl", hash = "sha256:e8413f2081e77c04a4ba379bdb93620c0753bd7bc335127773c318ce3526b1b9", size = 12774, upload-time = "2026-10-19T19:03:29.144Z" }, +] + +[[package]] +name = "juliapkg" +version = "0.1.28" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "semver" }, + { name = "tomli" }, + { name = "tomlkit" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ce/b1/965f7b066df488d7328fb448cf09b5647d2958266742e8e124239135c9fb/juliapkg-0.1.28.tar.gz", hash = "sha256:24f3ca545263e090f57521f47900bbb94ee7ebc9d91c55c82e4148aaf1b58e36", size = 27403, upload-time = "2026-10-24T21:24:35.341Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/18/5b8ebec81b05ce0bf355118992cdb94a97cdfe19e60662f99e2059e61b73/juliapkg-0.1.28-py3-none-any.whl", hash = "sha256:e09640eb5d3465eda0ea40fda912048cc06f34e1a3880eb9e46f4e2c836d8d48", size = 23609, upload-time = "2026-10-24T21:24:34.26Z" }, +] + [[package]] name = "kiwisolver" version = "1.5.1" @@ -1534,6 +1561,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/12/11/263ced30149fbede00614a11f01de792842d3636b5a9e3abfee34e764a0e/scipy_stubs-1.18.1.0-py3-none-any.whl", hash = "sha256:fc1f00da3eb6bf1adf2138774b5e6a91dcf7c77039ff199577dc47929c10793e", size = 653731, upload-time = "2026-08-22T09:22:51.43Z" }, ] +[[package]] +name = "semver" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/92/f5/e1dfe8e1d91c54ce212fd93916eb01fd1c590f413be0a0978c39a97aa1bb/semver-3.1.0.tar.gz", hash = "sha256:14bc073439513d7773662a338f4db9829cf16c12b74b9568e2d2689975fbd7fc", size = 304162, upload-time = "2026-09-12T18:38:14.045Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/02/bce7a1d70e9d0f6ea8623c16386138c251b5855af6cd3a11433d3fba4e66/semver-3.1.0-py3-none-any.whl", hash = "sha256:6e4998f8b4762acdfea85f9bfd5b4032e0bb50038dc04bf82011b42d5d1145c5", size = 18783, upload-time = "2026-09-12T18:38:12.457Z" }, +] + [[package]] name = "setuptools" version = "84.2.1" @@ -1607,6 +1643,9 @@ dependencies = [ gui = [ { name = "solprop-gui" }, ] +julia = [ + { name = "juliacall" }, +] mlx = [ { name = "mlx", marker = "platform_machine == 'arm64' and sys_platform == 'darwin'" }, ] @@ -1649,6 +1688,7 @@ gui-test = [ requires-dist = [ { name = "h5py", specifier = ">=3.15" }, { name = "jaxtyping", specifier = ">=0.3.11" }, + { name = "juliacall", marker = "extra == 'julia'", specifier = "==0.9.37" }, { name = "matplotlib", specifier = ">=3.10.7" }, { name = "mlx", marker = "platform_machine == 'arm64' and sys_platform == 'darwin' and extra == 'mlx'", specifier = ">=0.32.4,<0.33" }, { name = "numpy", specifier = ">=2.5" }, @@ -1660,7 +1700,7 @@ requires-dist = [ { name = "tomli-w", specifier = ">=1.0" }, { name = "tqdm", specifier = ">=4.67" }, ] -provides-extras = ["gui", "mlx"] +provides-extras = ["gui", "julia", "mlx"] [package.metadata.requires-dev] dev = [ @@ -1854,6 +1894,51 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" }, ] +[[package]] +name = "tomli" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/78/9ad63712633ed3ab5cc1a648d863d7e7da371e9425e209555a0fe711b695/tomli-2.5.0.tar.gz", hash = "sha256:264507556cd8b8c8e7c6ee037cdf443a463f03f4c958e57195e3d369711b8ff6", size = 17662, upload-time = "2026-10-07T12:23:37.892Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/49/caf6b307766eb9567664a8707e9d6be5fcc0e8903f18781c6677a60d80c7/tomli-2.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d3182ee2d887e507bd67319a0a61105d1dd33facc111329559a233b772c1a105", size = 162899, upload-time = "2026-10-07T12:22:50.088Z" }, + { url = "https://files.pythonhosted.org/packages/d3/c8/68cfce773a2733a49c74f99d627fb461bd990756860099eac25617889585/tomli-2.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:521345fd1f19d45b8df87657aaa38b6f2ca3800059fadf428e7ebf479a383646", size = 162080, upload-time = "2026-10-07T12:22:51.558Z" }, + { url = "https://files.pythonhosted.org/packages/7e/b2/e5bb8651fdad593f670501a7d718b1a7f73f064d44dea15e04c04dfef45d/tomli-2.5.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e95c7614e705bfe2b04b27aa124adec59752d15813df37e2156747cab3a006b", size = 273380, upload-time = "2026-10-07T12:22:52.918Z" }, + { url = "https://files.pythonhosted.org/packages/8d/d2/9e2d7f8b1dfe0e2b34c245986ebd55c4c553ea4ce6c47c443b332673253f/tomli-2.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ac2027d37c3afbdf4bdd377f2676f6f1d2122a5be1f1137b49dced590b37e75", size = 283228, upload-time = "2026-10-07T12:22:54.173Z" }, + { url = "https://files.pythonhosted.org/packages/ba/df/ec7b876b7b1a2718bd74a3743c076fff565b04029ba33e8f61fac262739f/tomli-2.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c414be4ed9d3cac80c42e348fa5a956117d1a48227f48026e31f59cb4a7671eb", size = 277189, upload-time = "2026-10-07T12:22:55.342Z" }, + { url = "https://files.pythonhosted.org/packages/7d/7b/e192d9eed0b9cb80da799f4d77052297fb9a2c3cc9b19f571f56ea88add6/tomli-2.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9b03d7dc168353b4132965bde20feceabaa470e570c6f59660dfae59b1f9eeb3", size = 283632, upload-time = "2026-10-07T12:22:56.735Z" }, + { url = "https://files.pythonhosted.org/packages/84/50/ff94454e75461d75623e47401ed323d65c10aab8fe9033242c20cd2fdf32/tomli-2.5.0-cp314-cp314-win32.whl", hash = "sha256:6f041843c4d3a37245c0c056fd955b186bf8b1fb85690cbe40b81230891dc34b", size = 103535, upload-time = "2026-10-07T12:22:58.084Z" }, + { url = "https://files.pythonhosted.org/packages/54/0b/bdacf05f963bd6026ebf6eeb0beda847d1d60e03e440725c64a4e08a0afd/tomli-2.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:f4b653094e18f9031102d3a1da5c729c8f222d85225b18037dac621695e46e1a", size = 114621, upload-time = "2026-10-07T12:22:59.2Z" }, + { url = "https://files.pythonhosted.org/packages/61/99/53f438fa6ae4f9d4ed0ddde3e7242b3bdc34b48c8f9948b72b9e9b127676/tomli-2.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:3f89d10c1ff6a38d992c27fc8a4816af71a909e08a40ec66934240b1e74347c3", size = 111572, upload-time = "2026-10-07T12:23:00.479Z" }, + { url = "https://files.pythonhosted.org/packages/b9/20/1f88f19427d380a40e90a770e087489eaafe4aeee070ae88ed2bbec00acd/tomli-2.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:e9e15b4a6c7dd6b85b5fbab29488a73f1f70de516942308daa266bf0e0aeb0d4", size = 171814, upload-time = "2026-10-07T12:23:01.914Z" }, + { url = "https://files.pythonhosted.org/packages/d0/56/cbe5079c9f9a54b9b3e27fc82f08f3cb36edee75561679f53d2380c801d6/tomli-2.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e12bbcd32897272fb05929110362ae9ff4c1b9bb26bd9e971e71dcd3275b4c3d", size = 171324, upload-time = "2026-10-07T12:23:03.18Z" }, + { url = "https://files.pythonhosted.org/packages/2b/30/1d53fd3b0f1cb3ba542e345ec32c26aefdddc4e829e4f3429af8a4f27782/tomli-2.5.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20aa36de8f2cf87237143bc1fa1aae8d6612c09118f4da21c6a684db5dd1f6f9", size = 297441, upload-time = "2026-10-07T12:23:04.345Z" }, + { url = "https://files.pythonhosted.org/packages/66/d9/0800acb6a111686f764c1b91ef15cc42a20a66a46013bb42220f1d2c61c1/tomli-2.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22185fad8a1e622f064e78008018a0dd3323550dcb479cb7a1d296888d74024f", size = 307476, upload-time = "2026-10-07T12:23:05.671Z" }, + { url = "https://files.pythonhosted.org/packages/e8/63/30a8f3cd51b5bec37f04744bad0b0dc6160df84aad4f27b0e9283d66f221/tomli-2.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:984012f71908165449a951de2050d52f276bfe3aa5d5f570f63ddad814370374", size = 296113, upload-time = "2026-10-07T12:23:07.202Z" }, + { url = "https://files.pythonhosted.org/packages/ab/18/0b9ffc597e69c5a1e20a7823cb60d54b39a9f54e91edcb8574f022186758/tomli-2.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f79203b3965b4000e91808aaa7c040206093f2b8bf86f455982f2274c9ccf442", size = 307725, upload-time = "2026-10-07T12:23:08.508Z" }, + { url = "https://files.pythonhosted.org/packages/ab/c7/18f8baae0b5607a60e8e19b4a7fedee43a8ff6458e3896dcbbadeeac9c22/tomli-2.5.0-cp314-cp314t-win32.whl", hash = "sha256:91294a9fb94a75542f6e46e4a2ae709bd8d9b51134098cae5cf3bea5478b6d03", size = 108546, upload-time = "2026-10-07T12:23:09.956Z" }, + { url = "https://files.pythonhosted.org/packages/72/34/4cca9739254130627bde87500b3f2b512154fe2f278efa7e2a5e10ad4bcb/tomli-2.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f15e3e0b835a6d68b10c86bf80a3149780498d6911c93c3ffd1861d19f9200f1", size = 117814, upload-time = "2026-10-07T12:23:11.486Z" }, + { url = "https://files.pythonhosted.org/packages/7d/fb/afa530d47dd80a78fce43beac6bc6e00f84558eafcffbc6f37b21e80d056/tomli-2.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6664b7ae7af7294256c53960a6103077f4914cec8ff98479c352f622c6f6b2f0", size = 115188, upload-time = "2026-10-07T12:23:12.728Z" }, + { url = "https://files.pythonhosted.org/packages/66/98/316fdc00f8c0939e6fe50461dd343c162d3ad51d1286eb25b7db54361d50/tomli-2.5.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:a525685c2f97da40762b8695eb7aa0af4c8344ca1905c73e4e29cb04d34607dc", size = 162775, upload-time = "2026-10-07T12:23:13.941Z" }, + { url = "https://files.pythonhosted.org/packages/c5/22/7b10fa5bb01c9539f53f69b619361b19350acc73657772ea7ac70ba309a8/tomli-2.5.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:9dbb18c1cfb2f6517942fc9314437f66aa06d94436ffb1f06102ef3572f35276", size = 161406, upload-time = "2026-10-07T12:23:15.215Z" }, + { url = "https://files.pythonhosted.org/packages/9c/e7/1a069d86dfd20f1f84f71c63faed9f83c1d890bc06c27d82dc7d888fb573/tomli-2.5.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:752e8b1aa6a4367ef8bf6a1a1e005540f7ed055ba36d7193796812ca5404eb52", size = 273855, upload-time = "2026-10-07T12:23:16.471Z" }, + { url = "https://files.pythonhosted.org/packages/ae/83/d1ef43d1687d092ab9c235455c76e6e709483b346b056f086095c7c263a5/tomli-2.5.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c47300f9bf791808f77d82747691c4bb09cb14bdf3060cca99b42cdc4361d5a7", size = 284910, upload-time = "2026-10-07T12:23:18.166Z" }, + { url = "https://files.pythonhosted.org/packages/cc/05/f4d9cf7de61822ece0c3873f30d291e324911c71a378b8bfe5ced13fd9f5/tomli-2.5.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:19b0dd8749f4ea2f112c5fcfb3c5248390c899d7e2e173f1d91abee1fa0ff391", size = 277723, upload-time = "2026-10-07T12:23:19.355Z" }, + { url = "https://files.pythonhosted.org/packages/42/28/78262493141fa543151cf005760c3cb01d09fc28a11f993c05109902cb8c/tomli-2.5.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:57b1c3b01fab802e2899bc3d168dca320e14165e2fd9fd584760fb4ca5826859", size = 285115, upload-time = "2026-10-07T12:23:20.698Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b9/e1dab9a30bcb677b5cc5cee810609cfd64f24306a3055767dd3fda00b1e0/tomli-2.5.0-cp315-cp315-win32.whl", hash = "sha256:667e521b37a6c5ccaa044202c235b530f90177ffe2cd4a64ecc213c7dd535feb", size = 103475, upload-time = "2026-10-07T12:23:21.941Z" }, + { url = "https://files.pythonhosted.org/packages/4c/bd/31a3790c11d6ea95fcf5e6022ac0f8d0543c9b61120b730fc481bd43d3b4/tomli-2.5.0-cp315-cp315-win_amd64.whl", hash = "sha256:d747252933c8a65ef6bd8da0fbb7ce28a90eb6119d8cd00772cd528aa07b68d5", size = 114589, upload-time = "2026-10-07T12:23:23.098Z" }, + { url = "https://files.pythonhosted.org/packages/47/a2/4f6310fa699364f0e3af7ee3af88dddd9af066d33e716a0265bbe2b3ea84/tomli-2.5.0-cp315-cp315-win_arm64.whl", hash = "sha256:75dbcde8751b0a960aa3de173aa5e894d590755c6d7758b7e774c06f1dc3cbdd", size = 111493, upload-time = "2026-10-07T12:23:24.233Z" }, + { url = "https://files.pythonhosted.org/packages/68/14/00853f0b396d8971107ae1921bb5b322fdee1650d2f16bf06c20adb532e5/tomli-2.5.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:2419c2a189551987b59d80e63ec355671283336f41c6b9b89462df679c7d0c57", size = 171380, upload-time = "2026-10-07T12:23:25.512Z" }, + { url = "https://files.pythonhosted.org/packages/89/ad/fa6949321dadee46b27363974fb197b94c911c3b0f7a5fd26d7dc18fc2a0/tomli-2.5.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:0dc598040da8d42cf20f0be588ed7004f46db12a0ac6c32e03a59dccedaaadcd", size = 170553, upload-time = "2026-10-07T12:23:26.855Z" }, + { url = "https://files.pythonhosted.org/packages/53/aa/3056c919eb3e084df3752b2cf5f865dcc04af0b27dba2f66d7b28af4633a/tomli-2.5.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49096930c8d886c9bbdab62d2d0d17ce823ddeea522309a190b36245d5b49e01", size = 294428, upload-time = "2026-10-07T12:23:28.132Z" }, + { url = "https://files.pythonhosted.org/packages/96/b2/faeeb5d8769ea3832021d73e892c8391eae7b4b4f8b55a789127bd8b18a9/tomli-2.5.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8ade5023067f99fe72b88accd30d0ea05a158e9e32a11f124e731ea9695313f", size = 304909, upload-time = "2026-10-07T12:23:29.381Z" }, + { url = "https://files.pythonhosted.org/packages/f6/52/f094c09e73fb654b621716d019acb5d29bdfd1be01df80c281d552bda48d/tomli-2.5.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b69564772b5c8f22ea5f498dff08cfa825045b4d4c4400529000bdf818aa3b2a", size = 293220, upload-time = "2026-10-07T12:23:30.608Z" }, + { url = "https://files.pythonhosted.org/packages/86/f5/0c30541078ca4b505ce3bd76ed931facbfec524dd018535d691d1af0a6d2/tomli-2.5.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:8ff3a2ca028c7eee0c777f9a092038d0a594a9fa04e215f929a22c329e2cb142", size = 305705, upload-time = "2026-10-07T12:23:32.181Z" }, + { url = "https://files.pythonhosted.org/packages/05/74/590e7d19d6a118fc5cc5704ff358e21d95b8573f6b9443b1519f29ca8825/tomli-2.5.0-cp315-cp315t-win32.whl", hash = "sha256:62fc1bc8eb03e3a9cadfca713d65614ed8e09d974a283295ffe3a831976b4dc5", size = 108432, upload-time = "2026-10-07T12:23:33.496Z" }, + { url = "https://files.pythonhosted.org/packages/1c/b8/63a75cfb27a17c38550e44025d3a6e7be64516fd8608a3b75703bf37d81b/tomli-2.5.0-cp315-cp315t-win_amd64.whl", hash = "sha256:f3fcbc57b1791fa6cbe5d8434179d51de12be1a4811469529f47f6e7487a2571", size = 117281, upload-time = "2026-10-07T12:23:34.648Z" }, + { url = "https://files.pythonhosted.org/packages/72/01/e8c1debb2173973372934c68fc8e46170ab60ef23ed4592dff4dec6e8993/tomli-2.5.0-cp315-cp315t-win_arm64.whl", hash = "sha256:d2ba24db8a9376921b5e87b4762b9adb0f3f1deaea68f2b8b0bb2c11efb9c3e7", size = 115069, upload-time = "2026-10-07T12:23:35.77Z" }, + { url = "https://files.pythonhosted.org/packages/60/3f/3e3f8fd0919249b0200c80fbc4f9a1e70be19f9883da71dfb7f8b9ab8aca/tomli-2.5.0-py3-none-any.whl", hash = "sha256:32a7b79ac57a2e83670ce329ccf675798bc5a2094783a63676866b70503f2e2b", size = 14765, upload-time = "2026-10-07T12:23:36.875Z" }, +] + [[package]] name = "tomli-w" version = "1.2.0"