From e7a25d915b9b59f6a1fe305ec99f2fa68e4cb6c9 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 12 Aug 2026 01:18:23 +0000 Subject: [PATCH 1/9] Add the Discreet Music tape-loop kernel and its shared tape machinery MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit tape_loop.h (tap::tools::tape) factors the pieces both Eno-family tape kernels compose, the way swing_vca.h holds the drum family's shared stages: reel (position-addressed circular tape, Hermite reads wrapped at a settable loop length), wow_flutter (deterministic dual-sine transport per the AES tape-echo literature), wear (darkening one-pole -> bounded swing_shape saturation -> normalized DC blocker), and the delay.h ramp. discreet.h (tap.discreet~) recreates the two-machine long-delay rig from the Discreet Music back-cover schematic. The design inversion the kernel exists to state: regeneration legally reaches 1.0, and stability comes from the wear path, not a feedback cap — with drive engaged the loop is BIBO-bounded at any regen, and at drive 0 the sub-cutoff band sustains indefinitely (the Frippertronics contract). Loop-time changes ride the ramp as honest tape-speed doppler. Tests pin the promises: echo grid to the sample, regen-1.0 non-growth over ten seconds, per-pass darkening measured against the analytic wear transfer, DC non-accumulation, wow depth measured by the YIN oracle against the closed-form deviation, bitwise mix endpoints, doppler glide re-lock, and bit-exact reproducibility. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_016zgrm1MGS1eir4hCfZBJaR --- README.md | 7 + include/taptools/discreet.h | 242 +++++++++++++++++++++++++ include/taptools/tape_loop.h | 260 +++++++++++++++++++++++++++ include/taptools/taptools.h | 2 + tests/CMakeLists.txt | 1 + tests/discreet_test.cpp | 340 +++++++++++++++++++++++++++++++++++ 6 files changed, 852 insertions(+) create mode 100644 include/taptools/discreet.h create mode 100644 include/taptools/tape_loop.h create mode 100644 tests/discreet_test.cpp diff --git a/README.md b/README.md index a569985..c658c73 100644 --- a/README.md +++ b/README.md @@ -71,6 +71,13 @@ header adds no nested namespace, the class) the kernel lives in. | `grm_comb.h` | `tap.5comb~` | GRM comb-bank recreation (`tap::tools::fivecomb`) | | `grm_pitchaccum.h` | `tap.pitchaccum~` | GRM PitchAccum recreation (`tap::tools::pitchaccum`) | +**Tape and loops** + +| Kernel | Max object | Contents | +|---|---|---| +| `tape_loop.h` | *(shared)* | Tape reel, wow/flutter transport, generation-loss wear (`tap::tools::tape`) | +| `discreet.h` | `tap.discreet~` | *Discreet Music* two-machine regeneration loop (`tap::tools::discreet`) | + `taptools.h` is the umbrella header that pulls in every kernel above. `stft.h`, `tune.h`, `harmonizer.h` and `conv_engine.h` reach into `tap::dsp` (the pinned DspTap submodule) for the real FFT and the pitch primitives; every other kernel is standard library only. diff --git a/include/taptools/discreet.h b/include/taptools/discreet.h new file mode 100644 index 0000000..6f4691f --- /dev/null +++ b/include/taptools/discreet.h @@ -0,0 +1,242 @@ +/// @file +/// @brief Portable long-loop tape regeneration kernel for tap.discreet~ — no Max/Min +/// dependency. +/// @details A recreation of the two-tape-machine long-delay system Brian Eno printed as a +/// signal-flow schematic on the back cover of *Discreet Music* (Obscure/EG, 1975) — +/// the same rig Robert Fripp ran for the *No Pussyfooting* loops: input is recorded +/// onto tape by machine A, the tape spools for seconds to machine B, and machine B's +/// playback is both the output and the signal folded back into machine A's record +/// head. The tape-path DSP (fractional read, periodic wow/flutter, in-loop +/// coloration) follows the published tape-echo modeling literature (Arnardottir, +/// Abel, Smith, "A Digital Model of the Echoplex Tape Delay", AES 125, 2008; +/// Valimaki et al.'s tape-echo work). +/// +/// The design inversion this kernel exists to state: delay.h keeps its feedback loop +/// stable by capping feedback strictly below 1; here regeneration deliberately +/// reaches 1.0, and stability comes from the tape path itself (tape_loop.h `wear`: +/// darkening lowpass -> bounded soft saturation -> DC blocker). Each pass survives +/// *because* it is degraded — wear is the stabilizer, not an fb cap. With drive +/// engaged the loop output is absolutely bounded at any regeneration in [0, 1]; at +/// drive 0 and regen 1.0 the band below the darkening cutoff sustains indefinitely, +/// cleanly — the Frippertronics contract. +/// +/// The performance surface mirrors the rig: `input_level` is the send fader Eno rode +/// (fade the input while the loop sustains and the piece keeps evolving without you), +/// `regen` is the return level into the record head, `loop_seconds` is the tape span +/// between the machines, and wow/flutter are the transport. +/// +/// Geometry: prepare(sr, max_loop_seconds) buys the worst case once — the family's +/// biggest single buy (30 s at 48 kHz is ~11.5 MB of double tape); size it to the +/// piece. No later call allocates; setters only retarget ramps and are safe while +/// audio runs. All processing is double-precision, per-sample, mono. +/// +/// Honest limits: +/// - `set_loop_seconds` glides as a tape-speed change and audibly bends pitch while +/// moving — by design (moving the read head IS the doppler); use set_smooth_ms to +/// choose how fast the transport re-spools. There is no crossfading "digital" mode. +/// - regen 1.0 sustains forever by design. Bring `regen` down (or darken harder) to +/// end a piece; clear() is the eject button. +/// - The wow/flutter transport is periodic only (see tape_loop.h) — deterministic, +/// reproducible, no stochastic capstan drift. +/// - The read floor is 2.5 samples (Hermite support), and wow excursion is clamped so +/// the read can never cross the record head; extreme wow depths at very short loops +/// flatten against that clamp rather than wrapping. +/// - Fresh input reaches the output only via the tape (the dry path is the input +/// itself, mixed equal-power): you hear a new note un-recirculated once, a loop +/// later it returns worn. No gain staging beyond input_level — that is the +/// caller's job. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include + +#include "tape_loop.h" // tap::tools::tape — reel / wow_flutter / wear / ramp, the shared machinery + +namespace tap::tools { + namespace discreet { + + constexpr double k_min_loop_seconds = 0.1; // below this it is a comb, not a loop + constexpr double k_regen_max = 1.0; // deliberately reaches unity: wear is the stabilizer + constexpr double k_default_loop_seconds = 5.0; // the order of Eno's machine-to-machine span + constexpr double k_default_max_seconds = 30.0; // default worst-case buy (~11.5 MB @ 48k) + constexpr double k_default_darken_hz = 3000.0; // gentle generation loss per pass + constexpr double k_default_drive = 0.5; // mild record-head saturation + constexpr double k_default_wow_ms = 1.0; // ~9 cents peak at 0.8 Hz (see the tests) + constexpr double k_default_wow_hz = 0.8; + constexpr double k_default_flutter_ms = 0.05; + constexpr double k_default_flutter_hz = 8.0; + constexpr double k_default_mix = 50.0; // half in the room, half on the tape + constexpr double k_default_smooth_ms = 20.0; // anti-zipper ramp for setters + + /// The two-machine loop: record head, seconds of tape, playback head, worn return path. + class machine { + public: + /// Defaults are a tape machine, not a neutral bypass: a 5 s span, gentle wear, the + /// stock transport breathing. Regen starts at 0 — the loop recirculates when you send. + machine() { + m_loop_seconds.snap(k_default_loop_seconds); + m_darken_hz.snap(k_default_darken_hz); + m_drive.snap(k_default_drive); + m_input_level.snap(1.0); + m_mix.snap(k_default_mix); + m_transport.set_wow(k_default_wow_ms, k_default_wow_hz); + m_transport.set_flutter(k_default_flutter_ms, k_default_flutter_hz); + } + + // -- lifecycle ----------------------------------------------------------------------- + + /// (Re)allocate tape for `max_loop_seconds` at `sr`, snap all ramps (a DSP restart is + /// not a parameter move), and erase the tape. Not real-time-safe. + void prepare(double sr, double max_loop_seconds = k_default_max_seconds) { + m_sr = (sr > 0.0) ? sr : 48000.0; + m_reel.prepare(m_sr, std::max(k_min_loop_seconds, max_loop_seconds)); + m_transport.prepare(m_sr); + m_wear.prepare(m_sr); + m_loop_seconds.snap(std::min(m_loop_seconds.target(), static_cast(m_reel.capacity()) / m_sr)); + m_regen.snap(m_regen.target()); + m_darken_hz.snap(m_darken_hz.target()); + m_drive.snap(m_drive.target()); + m_input_level.snap(m_input_level.target()); + m_mix.snap(m_mix.target()); + m_wear.set_cutoff_hz(m_darken_hz.current()); + m_wear.set_drive(m_drive.current()); + clear(); + } + + /// Erase the tape and the wear/transport state; parameters are untouched. The eject + /// button: regen 1.0 material is gone for good. + void clear() { + m_reel.clear(); + m_wear.clear(); + m_transport.clear(); + m_head = 0; + } + + bool prepared() const { return m_reel.prepared(); } + + // -- parameter targets (click-free; safe while audio runs) --------------------------- + + /// Tape span between the machines, in seconds, clamped to [k_min_loop_seconds, the + /// prepared max]. Slewed — and the slew IS the tape-speed doppler (see Honest limits). + void set_loop_seconds(double s) { + m_loop_seconds.to(std::clamp(s, k_min_loop_seconds, max_loop_seconds()), smooth_samples()); + } + + /// Return level into the record head, clamped to [0, 1]. 1.0 is legal and sustains. + void set_regen(double r) { m_regen.to(std::clamp(r, 0.0, k_regen_max), smooth_samples()); } + + /// Per-pass darkening corner in Hz (tape_loop.h wear band), slewed. + void set_darken_hz(double hz) { + m_darken_hz.to(std::clamp(hz, tape::k_darken_floor_hz, tape::k_darken_ceil_hz), smooth_samples()); + } + + /// Record-head saturation drive, >= 0, slewed. 0 is exactly linear (no wear boundedness + /// — the loop then relies on darkening alone; see the header banner). + void set_drive(double d) { m_drive.to(std::max(0.0, d), smooth_samples()); } + + /// The send fader: input level into the record head, linear, slewed. Fading this while + /// the loop sustains is the Discreet Music performance move. + void set_input_level(double lin) { m_input_level.to(lin, smooth_samples()); } + + /// Dry/wet mix 0..100, equal-power, slewed. 0 is bitwise dry, 100 bitwise wet. + void set_mix(double pct) { m_mix.to(std::clamp(pct, 0.0, 100.0), smooth_samples()); } + + /// Wow: depth in ms of tape position, rate in Hz. Instant transport config, not ramped. + void set_wow(double depth_ms, double rate_hz) { m_transport.set_wow(depth_ms, rate_hz); } + + /// Flutter: the faster, shallower partner. Instant transport config, not ramped. + void set_flutter(double depth_ms, double rate_hz) { m_transport.set_flutter(depth_ms, rate_hz); } + + /// Anti-zipper ramp time for the setters, in ms. 0 = instant (useful for tests). + void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + + // -- introspection ------------------------------------------------------------------- + + double loop_seconds() const { return m_loop_seconds.target(); } + double regen() const { return m_regen.target(); } + double darken_hz() const { return m_darken_hz.target(); } + double drive() const { return m_drive.target(); } + double input_level() const { return m_input_level.target(); } + double mix() const { return m_mix.target(); } + double wow_depth_ms() const { return m_transport.wow_depth_ms(); } + double wow_rate_hz() const { return m_transport.wow_rate_hz(); } + double flutter_depth_ms() const { return m_transport.flutter_depth_ms(); } + double flutter_rate_hz() const { return m_transport.flutter_rate_hz(); } + double smooth_ms() const { return m_smooth_ms; } + double max_loop_seconds() const { return static_cast(m_reel.capacity()) / m_sr; } + double samplerate() const { return m_sr; } + + // -- audio --------------------------------------------------------------------------- + + double process(double in) { + if (!prepared()) { + return in; + } + const double loop_s = m_loop_seconds.tick(); + const double regen = m_regen.tick(); + const double darken = m_darken_hz.tick(); + const double drive = m_drive.tick(); + const double send = m_input_level.tick(); + const double mix = m_mix.tick(); + + if (darken != m_wear.cutoff_hz()) { + m_wear.set_cutoff_hz(darken); + } + if (drive != m_wear.drive()) { + m_wear.set_drive(drive); + } + + // Machine B's playback head: loop_s behind the record head, breathed by the + // transport, clamped so the Hermite support can never cross the record head. + const double span = loop_s * m_sr - m_transport.tick(); + const double d_samples = + std::clamp(span, tape::k_min_frac_delay, static_cast(m_reel.capacity()) - 2.0); + const double played = m_reel.read_hermite(static_cast(m_head) - d_samples); + + // The return path: playback -> wear (darken, saturate, DC block) -> record head. + m_reel.write(m_head, send * in + regen * m_wear.process(played)); + if (++m_head >= m_reel.capacity()) { // keep the head in [0, capacity): a long can + m_head = 0; // overflow in half a day of audio on LLP64 + } + + // Equal-power dry/wet with exact endpoints (delay.h law: 0 bitwise dry, 100 wet). + if (mix <= 0.0) { + return in; + } + if (mix >= 100.0) { + return played; + } + const double theta = mix * 0.01 * (tape::k_pi * 0.5); + return std::cos(theta) * in + std::sin(theta) * played; + } + + /// Block form: the trivial loop over the scalar path. + void process(const double* in, double* out, size_t n) { + for (size_t i = 0; i < n; ++i) { + out[i] = process(in[i]); + } + } + + private: + long smooth_samples() const { return static_cast(m_smooth_ms * 0.001 * m_sr); } + + double m_sr{48000.0}; + double m_smooth_ms{k_default_smooth_ms}; + long m_head{0}; + tape::reel m_reel; + tape::wow_flutter m_transport; + tape::wear m_wear; + tape::ramp m_loop_seconds; // seconds + tape::ramp m_regen; // 0..1 + tape::ramp m_darken_hz; // Hz + tape::ramp m_drive; // >= 0 + tape::ramp m_input_level; // linear + tape::ramp m_mix; // 0..100 + }; + + } // namespace discreet +} // namespace tap::tools diff --git a/include/taptools/tape_loop.h b/include/taptools/tape_loop.h new file mode 100644 index 0000000..40e30f7 --- /dev/null +++ b/include/taptools/tape_loop.h @@ -0,0 +1,260 @@ +/// @file +/// @brief Shared tape-loop machinery for the Eno family (discreet.h, airport.h) — no Max/Min +/// dependency. +/// @details The building blocks both tape kernels compose, factored the way swing_vca.h holds +/// the drum family's shared stages: a class with state is shared by include, a +/// few-line expression is copied with a citation. +/// +/// - `reel` — a circular span of tape. Storage is bought once at prepare() (the +/// worst-case loop), and reads/writes wrap at a settable loop length, so the same +/// class serves a delay-line topology (loop length == capacity, an advancing write +/// head trailed by a read head — discreet.h) and a fixed-loop topology (loop length +/// set per piece, one free-running head that both plays and records — airport.h). +/// Fractional reads use the family's 4-point, 3rd-order Hermite. +/// - `wow_flutter` — the tape-transport speed error as a deterministic pair of sines +/// (slow/deep wow, fast/shallow flutter) returning a read-position offset in +/// samples. Periodic-only by design: the periodic term is the dominant one in the +/// tape-echo literature (Arnardottir, Abel, Smith, "A Digital Model of the Echoplex +/// Tape Delay", AES 125, 2008), and a deterministic transport means renders and +/// tests reproduce bit-exactly. Real capstan drift also has a stochastic term; that +/// is a documented non-goal here. +/// - `wear` — one pass of generation loss: a record/playback darkening one-pole +/// lowpass, then the shared soft saturator (vca::swing_shape — tanh(d*v)/d, exact +/// linear passthrough at drive 0), then the family's normalized DC blocker. This is +/// the load-bearing inversion of delay.h's stability story: swing_shape is bounded +/// by 1/drive for any drive > 0, so a regeneration loop built on wear is BIBO- +/// bounded even at unity regeneration — degradation is the stability mechanism, +/// where delay.h caps feedback below 1 instead. At drive 0 the saturator is exactly +/// linear and only the lowpass and DC blocker contract the loop; a sub-cutoff band +/// fed back at unity then sustains indefinitely — that is the Frippertronics +/// contract, stated, not hidden. +/// - `ramp` — the per-sample linear anti-zipper unit, same shape as delay.h, copied +/// here so both tape kernels share one without dragging in a whole delay kernel. +/// +/// All processing is double-precision, per-sample, allocation-free after prepare(). +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include +#include + +#include "vca.h" // tap::tools::vca::swing_shape — the shared soft saturator + +namespace tap::tools { + namespace tape { + + constexpr double k_pi = 3.14159265358979323846; + constexpr long k_min_loop_samples = 8; // Hermite needs 4 support points; margin as delay_buffer + constexpr double k_min_frac_delay = 2.5; // same floor, same reason as delay.h + constexpr double k_dc_block_r = 0.999; // in-loop DC blocker pole (~7 Hz corner @ 48k) + // Normalized to unity peak gain so the blocker never amplifies the loop (grm_comb.h). + constexpr double k_dc_block_norm = (1.0 + k_dc_block_r) * 0.5; + constexpr double k_darken_floor_hz = 20.0; // wear cutoff range: the audible band + constexpr double k_darken_ceil_hz = 20000.0; + constexpr double k_wow_rate_max_hz = 5.0; // transport wow lives below a few Hz + constexpr double k_flutter_rate_max_hz = 30.0; // flutter sits above wow, below audio rate + + /// Per-sample linear parameter ramp — the anti-zipper unit every setter retargets. + /// Same shape as delay.h's ramp. + class ramp { + public: + void snap(double v) { + m_current = m_target = v; + m_inc = 0.0; + m_remaining = 0; + } + + void to(double tgt, long nsamples) { + if (nsamples < 1 || tgt == m_current) { + snap(tgt); + } + else { + m_target = tgt; + m_inc = (tgt - m_current) / static_cast(nsamples); + m_remaining = nsamples; + } + } + + double tick() { + if (m_remaining > 0) { + m_current += m_inc; + if (--m_remaining == 0) { + m_current = m_target; + } + } + return m_current; + } + + double current() const { return m_current; } + double target() const { return m_target; } + + private: + double m_current{0.0}; + double m_target{0.0}; + double m_inc{0.0}; + long m_remaining{0}; + }; + + /// One spool of tape: position-addressed circular storage with fractional Hermite reads. + /// Positions may be any long/double — they wrap modulo the active loop length, so callers + /// keep monotonically advancing heads and never do their own modular arithmetic. + class reel { + public: + /// Buy the worst-case loop once. Loop length starts at full capacity. Not real-time-safe. + void prepare(double sr, double max_seconds) { + const double worst = std::ceil(std::max(0.0, max_seconds) * ((sr > 0.0) ? sr : 48000.0)); + m_tape.assign(static_cast(std::max(k_min_loop_samples, worst)), 0.0); + m_loop_samples = static_cast(m_tape.size()); + } + + /// Erase the tape; loop length and caller-held heads are untouched. + void clear() { std::fill(m_tape.begin(), m_tape.end(), 0.0); } + + bool prepared() const { return !m_tape.empty(); } + long capacity() const { return static_cast(m_tape.size()); } + long loop_samples() const { return m_loop_samples; } + + /// Set the active loop length, clamped to [k_min_loop_samples, capacity]. A splice: + /// tape content is kept, positions simply re-wrap modulo the new length. + void set_loop_samples(long n) { m_loop_samples = std::clamp(n, k_min_loop_samples, capacity()); } + + void write(long pos, double x) { m_tape[wrap(pos)] = x; } + + /// 4-point, 3rd-order Hermite at fractional position `pos` (wrapped modulo the loop + /// length). Same read as delay.h / grm_comb.h. + double read_hermite(double pos) const { + const double fpos = std::floor(pos); + const double frac = pos - fpos; + const long base = static_cast(fpos); + const double xm1 = m_tape[wrap(base - 1)]; + const double x0 = m_tape[wrap(base)]; + const double x1 = m_tape[wrap(base + 1)]; + const double x2 = m_tape[wrap(base + 2)]; + const double c = (x1 - xm1) * 0.5; + const double v = x0 - x1; + const double w = c + v; + const double a = w + v + (x2 - x0) * 0.5; + const double b = w + a; + return (((a * frac - b) * frac + c) * frac + x0); + } + + private: + // Same wrap as delay.h, against the loop length rather than the buffer size. + size_t wrap(long i) const { + return static_cast(((i % m_loop_samples) + m_loop_samples) % m_loop_samples); + } + + std::vector m_tape; + long m_loop_samples{k_min_loop_samples}; + }; + + /// Deterministic transport speed error: wow + flutter as two sines, returning a read- + /// position offset in samples. Phases start at zero at prepare()/clear(), so two runs of + /// the same settings are bit-exact. + class wow_flutter { + public: + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + clear(); + } + + void clear() { m_wow_phase = m_flutter_phase = 0.0; } + + /// Wow: excursion depth in ms of tape position, rate in Hz (clamped to the wow band). + void set_wow(double depth_ms, double rate_hz) { + m_wow_depth_ms = std::max(0.0, depth_ms); + m_wow_rate_hz = std::clamp(rate_hz, 0.0, k_wow_rate_max_hz); + } + + /// Flutter: the faster, shallower partner (clamped to the flutter band). + void set_flutter(double depth_ms, double rate_hz) { + m_flutter_depth_ms = std::max(0.0, depth_ms); + m_flutter_rate_hz = std::clamp(rate_hz, 0.0, k_flutter_rate_max_hz); + } + + double wow_depth_ms() const { return m_wow_depth_ms; } + double wow_rate_hz() const { return m_wow_rate_hz; } + double flutter_depth_ms() const { return m_flutter_depth_ms; } + double flutter_rate_hz() const { return m_flutter_rate_hz; } + + /// Advance one sample; returns this sample's position offset in samples. + double tick() { + const double wow = m_wow_depth_ms * 0.001 * m_sr * std::sin(2.0 * k_pi * m_wow_phase); + const double flutter = m_flutter_depth_ms * 0.001 * m_sr * std::sin(2.0 * k_pi * m_flutter_phase); + m_wow_phase += m_wow_rate_hz / m_sr; + m_wow_phase -= std::floor(m_wow_phase); + m_flutter_phase += m_flutter_rate_hz / m_sr; + m_flutter_phase -= std::floor(m_flutter_phase); + return wow + flutter; + } + + private: + double m_sr{48000.0}; + double m_wow_depth_ms{0.0}; + double m_wow_rate_hz{0.0}; + double m_flutter_depth_ms{0.0}; + double m_flutter_rate_hz{0.0}; + double m_wow_phase{0.0}; + double m_flutter_phase{0.0}; + }; + + /// One pass of generation loss: darkening one-pole lowpass -> bounded soft saturation -> + /// normalized DC blocker. The stabilizer of the regeneration loops built on it (see the + /// file banner: bounded by 1/drive for any drive > 0, contractive above the cutoff). + class wear { + public: + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + update_coeff(); + clear(); + } + + void clear() { + m_lp = 0.0; + m_dc_x1 = 0.0; + m_dc_y1 = 0.0; + } + + /// Record/playback darkening corner, clamped to the audible band. Exact one-pole + /// coefficient, same map as grm_comb.h (tap.comb~'s cruder hz*2/sr was rejected there). + void set_cutoff_hz(double hz) { + m_cutoff_hz = std::clamp(hz, k_darken_floor_hz, k_darken_ceil_hz); + update_coeff(); + } + + /// Saturation drive, >= 0. 0 is an exact linear passthrough (vca::swing_shape contract). + void set_drive(double d) { m_drive = std::max(0.0, d); } + + double cutoff_hz() const { return m_cutoff_hz; } + double drive() const { return m_drive; } + + double process(double x) { + m_lp += m_lp_a * (x - m_lp); + const double sat = vca::swing_shape(m_lp, m_drive); + const double dc_out = k_dc_block_norm * (sat - m_dc_x1) + k_dc_block_r * m_dc_y1; + m_dc_x1 = sat; + m_dc_y1 = anti_denormal(dc_out); + return m_dc_y1; + } + + private: + void update_coeff() { m_lp_a = 1.0 - std::exp(-2.0 * k_pi * m_cutoff_hz / m_sr); } + + static double anti_denormal(double x) { return (std::abs(x) < 1e-15) ? 0.0 : x; } // same guard as tap.comb~ + + double m_sr{48000.0}; + double m_cutoff_hz{k_darken_ceil_hz}; + double m_drive{0.0}; + double m_lp_a{1.0}; + double m_lp{0.0}; + double m_dc_x1{0.0}; + double m_dc_y1{0.0}; + }; + + } // namespace tape +} // namespace tap::tools diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index 4d4983c..03c93bf 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -12,6 +12,7 @@ #include "conv_engine.h" #include "delay.h" #include "diode_ladder.h" +#include "discreet.h" #include "grm_comb.h" #include "grm_pitchaccum.h" #include "ladder.h" @@ -22,6 +23,7 @@ #include "stft.h" #include "svf.h" #include "swing_vca.h" +#include "tape_loop.h" #include "tb303_voice.h" #include "tr808_clap.h" #include "tr808_cowbell.h" diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index c6cc13f..b38c71d 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -16,6 +16,7 @@ add_executable(taptools_kernel_tests autowah_test.cpp delay_test.cpp diode_ladder_test.cpp + discreet_test.cpp grm_comb_test.cpp harmonizer_test.cpp nr_test.cpp diff --git a/tests/discreet_test.cpp b/tests/discreet_test.cpp new file mode 100644 index 0000000..c62062e --- /dev/null +++ b/tests/discreet_test.cpp @@ -0,0 +1,340 @@ +/// @file +/// @brief Catch2 scenarios pinning the tap.discreet~ kernel (discreet.h + tape_loop.h). +/// @details Oracle-based where the promise is musical: pitch claims (wow depth, the tape-speed +/// doppler of a loop-time change) are measured with the DspTap YIN detector, spectral +/// claims (per-pass darkening) with a local Goertzel against the analytically +/// predicted per-pass transfer, and the headline stability claim — regeneration at +/// exactly 1.0 stays bounded because the wear path is the stabilizer — with the +/// two-window RMS pattern from grm_comb_test.cpp. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + + using tap::tools::discreet::machine; + + /// A machine with the transport parked and instant setters: tests opt into wow explicitly. + machine make(double max_loop_seconds = 4.0) { + machine m; + m.prepare(k_sr, max_loop_seconds); + m.set_smooth_ms(0.0); + m.set_wow(0.0, 0.0); + m.set_flutter(0.0, 0.0); + m.set_input_level(1.0); + m.set_mix(100.0); // wet only: the tape is what these tests measure + return m; + } + + size_t at(double seconds) { + return static_cast(seconds * k_sr); + } + + double rms(const std::vector& x, size_t begin, size_t end) { + double acc = 0.0; + for (size_t i = begin; i < end; ++i) { + acc += x[i] * x[i]; + } + return std::sqrt(acc / static_cast(end - begin)); + } + + double mean(const std::vector& x, size_t begin, size_t end) { + double acc = 0.0; + for (size_t i = begin; i < end; ++i) { + acc += x[i]; + } + return acc / static_cast(end - begin); + } + + double peak(const std::vector& x, size_t begin, size_t end) { + double p = 0.0; + for (size_t i = begin; i < end; ++i) { + p = std::max(p, std::abs(x[i])); + } + return p; + } + + /// Single-bin magnitude, 2|X(f)|/N — same probe as the tr808 tests. + double goertzel(const std::vector& x, double f, size_t begin, size_t end) { + const double w = 2.0 * 3.14159265358979323846 * f / k_sr; + const double coef = 2.0 * std::cos(w); + double s1 = 0.0, s2 = 0.0; + for (size_t i = begin; i < end; ++i) { + const double s = x[i] + coef * s1 - s2; + s2 = s1; + s1 = s; + } + const double n = static_cast(end - begin); + const double re = s1 - s2 * std::cos(w); + const double im = s2 * std::sin(w); + return 2.0 * std::sqrt(re * re + im * im) / n; + } + + /// YIN oracle at an offset — same detector setup as tune_test.cpp / harmonizer_test.cpp. + double measure_hz(const std::vector& x, size_t offset) { + const size_t tau_min = static_cast(k_sr / 2000.0); + const size_t tau_max = static_cast(std::ceil(k_sr / 55.0)); + tap::dsp::yin det(tau_max, tau_min, tau_max); + REQUIRE(x.size() >= offset + det.frame_size()); + const auto r = det.analyze(x.data() + offset); + REQUIRE(r.voiced()); + return k_sr / r.period; + } + + double cents(double f, double ref) { + return 1200.0 * std::log2(f / ref); + } + + /// Predicted per-pass magnitude of the wear path at drive 0: the exact one-pole lowpass times + /// the normalized DC blocker, evaluated on the unit circle — the same formulas the kernel + /// applies, computed independently here. + double wear_gain(double f, double cutoff_hz) { + const double w = 2.0 * 3.14159265358979323846 * f / k_sr; + const double a = 1.0 - std::exp(-2.0 * 3.14159265358979323846 * cutoff_hz / k_sr); + const auto ejw = std::exp(std::complex(0.0, -w)); + const double lp = std::abs(a / (1.0 - (1.0 - a) * ejw)); + const double r = tap::tools::tape::k_dc_block_r; + const double nm = tap::tools::tape::k_dc_block_norm; + const double dc = std::abs(nm * (1.0 - ejw) / (1.0 - r * ejw)); + return lp * dc; + } + + /// Deterministic noise, never denormal-small — same LCG as delay_test.cpp. + struct noise { + uint32_t state{2463534242u}; + double operator()() { + state = state * 1664525u + 1013904223u; + return (static_cast(state) / 2147483648.0) - 1.0; + } + }; + +} // namespace + +SCENARIO("the loop echoes at exactly the loop period") { + machine m = make(); + m.set_loop_seconds(0.5); + m.set_regen(0.7); + m.set_drive(0.0); + m.set_darken_hz(20000.0); + + const size_t loop = at(0.5); + std::vector y(at(1.8), 0.0); + for (size_t i = 0; i < y.size(); ++i) { + y[i] = m.process(i == 0 ? 1.0 : 0.0); + } + + // The first return is the recorded impulse itself, bit-exact at one loop (integer span, + // Hermite frac 0 reads x0 exactly; wear touches only the return path, not the first read). + REQUIRE(y[loop] == 1.0); + + // Later returns have passed the wear filter — smeared, but the peak stays on the grid. + for (size_t k = 2; k <= 3; ++k) { + const size_t lo = k * loop - 16; + const size_t hi = k * loop + 16; + size_t argmx = lo; + for (size_t i = lo; i < hi; ++i) { + if (std::abs(y[i]) > std::abs(y[argmx])) { + argmx = i; + } + } + INFO("echo " << k << " peak at " << argmx << ", grid " << k * loop); + CHECK(argmx >= k * loop - 1); + CHECK(argmx <= k * loop + 1); + } +} + +// Regeneration at exactly 1.0 is a legal, sustaining regime: boundedness comes from the wear +// path (bounded saturator + darkening + DC blocker), not from a feedback cap. Ten seconds of +// ring covers ~36 passes of a 0.25 s loop — long enough that the +0.2 dB/s class of swell the +// comb bank once had (grm_comb_test.cpp) would show clearly. +SCENARIO("regen 1.0 with drive engaged is bounded and does not grow") { + machine m = make(); + m.set_loop_seconds(0.25); + m.set_regen(1.0); + m.set_drive(0.5); + m.set_darken_hz(3000.0); + + noise rng; + std::vector y(at(10.0), 0.0); + for (size_t i = 0; i < y.size(); ++i) { + const double in = (i < at(1.0)) ? 0.5 * rng() : 0.0; + y[i] = m.process(in); + } + + const double early = rms(y, at(2.0), at(5.0)); + const double late = rms(y, at(6.0), at(9.0)); + INFO("ring RMS: [2,5)s = " << early << ", [6,9)s = " << late); + REQUIRE(std::isfinite(late)); + REQUIRE(late <= early * 1.02); // sustain is the contract: no growth, decay not required + REQUIRE(peak(y, 0, y.size()) < 3.0); // |wear out| <= 1/drive = 2, plus the direct send +} + +SCENARIO("every pass through the loop is darker by the wear filter") { + machine m = make(); + m.set_loop_seconds(0.25); + m.set_regen(0.9); + m.set_drive(0.0); // linear wear: the per-pass ratio is exactly regen * |H_wear| + m.set_darken_hz(2000.0); + + // A two-tone burst, one tone well above the darkening corner and one well below, so the + // test can assert both sides: highs die fast, lows barely fade (the honest tape story). + const double f_hi = 6000.0; + const double f_lo = 300.0; + const size_t loop = at(0.25); + std::vector y(at(1.5), 0.0); + for (size_t i = 0; i < y.size(); ++i) { + double in = 0.0; + if (i < at(0.1)) { + const double t = static_cast(i) / k_sr; + in = 0.4 * std::sin(2.0 * 3.14159265358979323846 * f_hi * t) + + 0.4 * std::sin(2.0 * 3.14159265358979323846 * f_lo * t); + } + y[i] = m.process(in); + } + + const double expect_hi = 0.9 * wear_gain(f_hi, 2000.0); + const double expect_lo = 0.9 * wear_gain(f_lo, 2000.0); + for (size_t k = 1; k <= 3; ++k) { + const double hi_a = goertzel(y, f_hi, k * loop, k * loop + at(0.1)); + const double hi_b = goertzel(y, f_hi, (k + 1) * loop, (k + 1) * loop + at(0.1)); + const double lo_a = goertzel(y, f_lo, k * loop, k * loop + at(0.1)); + const double lo_b = goertzel(y, f_lo, (k + 1) * loop, (k + 1) * loop + at(0.1)); + const double hi_ratio = hi_b / hi_a; + const double lo_ratio = lo_b / lo_a; + INFO("pass " << k << " -> " << k + 1 << ": hi ratio " << hi_ratio << " (predicted " << expect_hi + << "), lo ratio " << lo_ratio << " (predicted " << expect_lo << ")"); + CHECK(std::abs(hi_ratio - expect_hi) < 0.15 * expect_hi); + CHECK(std::abs(lo_ratio - expect_lo) < 0.05 * expect_lo); + CHECK(hi_ratio < lo_ratio); // both sides: the wear is a tilt, not a fader + } +} + +SCENARIO("a dc step does not accumulate, even at regen 1.0") { + machine m = make(); + m.set_loop_seconds(0.25); + m.set_regen(1.0); + m.set_drive(0.0); + m.set_darken_hz(3000.0); + + // Without the in-loop DC blocker, a held 0.5 input at regen 1.0 would add 0.5 every pass, + // without bound. With it, the running mean stays put and the tail's mean returns to zero. + std::vector y(at(4.0), 0.0); + for (size_t i = 0; i < y.size(); ++i) { + y[i] = m.process(i < at(2.0) ? 0.5 : 0.0); + } + + const double driven = peak(y, 0, at(2.0)); + const double tail = mean(y, at(3.5), at(4.0)); // 2 whole loops: an unbiased DC estimate + INFO("driven peak " << driven << ", tail mean " << tail); + REQUIRE(driven < 3.0); + REQUIRE(std::abs(tail) < 0.02); +} + +SCENARIO("wow bends pitch by the set depth, and two runs are bit-exact") { + const double depth_ms = 2.0; + const double rate_hz = 0.5; + // Peak deviation of a sinusoidally modulated read: ratio swings by depth * 2*pi*rate. + const double predicted = 1200.0 / std::log(2.0) * depth_ms * 0.001 * 2.0 * 3.14159265358979323846 * rate_hz; + + auto render = [&] { + machine m = make(); + m.set_loop_seconds(1.0); + m.set_regen(0.0); + m.set_wow(depth_ms, rate_hz); + std::vector y(at(4.5), 0.0); + for (size_t i = 0; i < y.size(); ++i) { + const double t = static_cast(i) / k_sr; + y[i] = m.process(0.8 * std::sin(2.0 * 3.14159265358979323846 * 440.0 * t)); + } + return y; + }; + + const std::vector y = render(); + + // Track the wet pitch across one full wow cycle (2 s), after the tape has filled. + double worst = 0.0; + for (size_t off = at(1.5); off + at(0.05) < at(3.5); off += 2048) { + worst = std::max(worst, std::abs(cents(measure_hz(y, off), 440.0))); + } + INFO("peak deviation " << worst << " cents, predicted " << predicted); + CHECK(worst > 0.6 * predicted); + CHECK(worst < 1.4 * predicted); + + const std::vector z = render(); + bool exact = true; + for (size_t i = 0; i < y.size(); ++i) { + exact = exact && (y[i] == z[i]); // bitwise: the transport is deterministic + } + REQUIRE(exact); +} + +SCENARIO("mix endpoints are bitwise exact") { + machine m = make(); + m.set_loop_seconds(0.5); + m.set_regen(0.5); + + m.set_mix(0.0); + noise rng; + bool exact = true; + for (int i = 0; i < 4800; ++i) { + const double in = rng(); + exact = exact && (m.process(in) == in); // bitwise, not approximately + } + REQUIRE(exact); +} + +SCENARIO("a loop-time change glides as tape speed, not a splice") { + machine m = make(); + m.set_loop_seconds(0.5); + m.set_regen(0.0); + + std::vector y; + y.reserve(at(4.5)); + auto run = [&](double seconds) { + for (size_t i = 0; i < at(seconds); ++i) { + const double t = static_cast(y.size()) / k_sr; + y.push_back(m.process(0.8 * std::sin(2.0 * 3.14159265358979323846 * 440.0 * t))); + } + }; + + run(2.0); // fill the tape at the short span + m.set_smooth_ms(500.0); + m.set_loop_seconds(0.75); // respool +0.25 s of span over 0.5 s: tape speed halves + run(0.5); + m.set_smooth_ms(0.0); + run(2.0); + + // Mid-glide the playback sits an octave down; after the ramp lands it re-locks to pitch. + const double gliding = measure_hz(y, at(2.2)); + const double settled = measure_hz(y, at(3.5)); + INFO("mid-glide " << gliding << " Hz, settled " << settled << " Hz"); + CHECK(std::abs(cents(gliding, 220.0)) < 60.0); + CHECK(std::abs(cents(settled, 440.0)) < 5.0); + + // And it is a glide: no splice discontinuity anywhere in the move. + double worst_step = 0.0; + for (size_t i = at(2.0) + 1; i < at(2.5); ++i) { + worst_step = std::max(worst_step, std::abs(y[i] - y[i - 1])); + } + INFO("largest sample step during the glide: " << worst_step); + CHECK(worst_step < 0.1); // a 440 Hz sine at 0.8 moves ~0.046/sample; a splice would jump ~1.6 +} + +SCENARIO("unprepared, the machine passes input through") { + machine m; + REQUIRE(m.process(0.7) == 0.7); + REQUIRE(m.process(-0.3) == -0.3); +} From 7bd740ea8d1f34d852095bfcc73bdf751ced843b Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 12 Aug 2026 01:22:44 +0000 Subject: [PATCH 2/9] Reach tap.discreet~ from the verification layer C ABI section, ctypes bridge class (Discreet), and the executed discreet.ipynb: the echo grid to the sample, twenty seconds of bounded regen-1.0 sustain, per-pass generation loss measured against the analytic wear transfer (0.292 and 0.890 per pass, both matching the prediction to three decimals), the wow transport pitch-tracked at 10.9 cents peak against the 10.9-cent closed form, and the fade-the-send performance move rendered end to end. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_016zgrm1MGS1eir4hCfZBJaR --- notebooks/discreet.ipynb | 469 +++++++++++++++++++++++++++++++++++ notebooks/taptools_py.py | 76 +++++- tools/capi/taptools_capi.cpp | 67 +++++ tools/capi/taptools_capi.h | 20 ++ 4 files changed, 631 insertions(+), 1 deletion(-) create mode 100644 notebooks/discreet.ipynb diff --git a/notebooks/discreet.ipynb b/notebooks/discreet.ipynb new file mode 100644 index 0000000..3fcb3a7 --- /dev/null +++ b/notebooks/discreet.ipynb @@ -0,0 +1,469 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d2d5bb06", + "metadata": {}, + "source": [ + "# tap.discreet~ — the loop, measured\n", + "\n", + "The *Discreet Music* two-tape-machine system (`taptools/discreet.h` + `taptools/tape_loop.h`):\n", + "input is recorded onto tape, spools for seconds to a second machine, and the playback is both\n", + "the output and the signal folded back into the record head. The kernel's headline claim is an\n", + "inversion of the usual delay-stability story: **regeneration legally reaches 1.0**, and\n", + "boundedness comes from the wear path (darkening lowpass → bounded soft saturation → DC\n", + "blocker), not from a feedback cap. Every trace below drives the **shipping C++** through\n", + "`tools/capi` via ctypes.\n", + "\n", + "Sections: **1** the echo grid · **2** wear as the stabilizer (regen 1.0, bounded) ·\n", + "**3** per-pass darkening vs. the analytic wear transfer · **4** the transport, in cents ·\n", + "**5** the performance move: fade the send, the loop carries on." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "23b3fce3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:22:17.715239Z", + "iopub.status.busy": "2026-08-12T01:22:17.714981Z", + "iopub.status.idle": "2026-08-12T01:22:18.285043Z", + "shell.execute_reply": "2026-08-12T01:22:18.283483Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import taptools_py as tap\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.2),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.3,\n", + "})\n", + "C = tap.PALETTE\n", + "sr = 48000.0\n", + "\n", + "def machine(**params):\n", + " base = dict(smooth_ms=0, wow=(0, 0), flutter=(0, 0), input_level=1.0, mix=100)\n", + " base.update(params)\n", + " return tap.Discreet(sr, 8.0, **base)\n", + "\n", + "def goertzel(x, f):\n", + " n = np.arange(x.size)\n", + " return 2.0 * np.abs(np.dot(x, np.exp(-2j * np.pi * f * n / sr))) / x.size" + ] + }, + { + "cell_type": "markdown", + "id": "2d7cba52", + "metadata": {}, + "source": [ + "## 1 · The echo grid\n", + "\n", + "An impulse into a 0.5 s loop at regen 0.7. The first return is the recorded impulse itself —\n", + "bit-exact at one loop, because the span is an integer number of samples and the Hermite read\n", + "at fraction 0 is exact — and every later return lands on the same grid, one wear pass darker.\n", + "(The kernel test pins the grid to ±1 sample: scenario *\"the loop echoes at exactly the loop\n", + "period\"*.)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "935d605c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:22:18.287447Z", + "iopub.status.busy": "2026-08-12T01:22:18.287171Z", + "iopub.status.idle": "2026-08-12T01:22:18.424164Z", + "shell.execute_reply": "2026-08-12T01:22:18.422824Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuAAAAE+CAYAAADMAqXLAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAOxAAADsQBlSsOGwAAUjhJREFUeJzt3Xd8FHX+P/DXZzabRoBACCkEAgQILfQiXQwdQUQkh9hP9MCGp19R8U455WwolrtT706xIagcRZQiRZAiHB2UIhAgPYSQBEg2ye7O5/cHl/0Zk8CGTXYnn3k9Hw8fsrOzs+/d1wy8d8pnhJRSgoiIiIiIvELzdQFERERERGbCBpyIiIiIyIvYgBMREREReREbcCIiIiIiL2IDTkRERETkRWzAiYiIiIi8iA04EREREZEXsQEnIiIiIvIiNuBEXlRaWorFixfjzJkzvi6lUkavr7ZdunQJixcvRnp6uq9LMTRvf0/79u3DsmXLsHfvXrdf8+2332Lx4sUV/ktLS6vFSq+du9teWloaFi9eDJvNdtVlSimxZMkSZGZm1tgyfem3debm5uKLL76A0+n0cWVE1ccGnMiLLly4gClTpmDLli2+LqVSRq+vtmVlZWHKlCnYtWuXr0sxBJvNhsWLFyMlJaXcdG99TwUFBRgyZAjGjBmDjz76CGPGjMGQIUNQUFBw1dc++uij+POf/4zly5eX+8+oP67c3fZ27NiBKVOmIDc396rL/Oyzz/DII48gNDS0xpb5a1WtH1VN99Rv62zYsCGeffZZvPfeezX6PkTe4OfrAojMJCAgAElJSWjZsqWvSyG6qtzcXEyZMgWLFi1CixYtvP7+06dPR0pKCn7++Wc0btwYubm56NGjB6ZPn47PP//8qq8fMWIE/va3v3mhUs/V9N8NdrsdTz/9NJ588kkEBQXVyDJ/q6r1w1vrjZ+fn+sz3nPPPQgODq619yKqaWzAibwoICAAEyZMQPPmzQFcPpT/zTffYNCgQYiKisLWrVths9kwZMgQBAYGAgDOnz+PH3/8EaGhoejfvz+EEK7l/fr1kZGR2LJlCy5duoQBAwagUaNGrvnOnTuH9evXY+TIkeWmp6SkYPv27ZgwYYLr/Spz4MABnDlzBlFRUejSpQsCAgLKPa/rOvbs2YPU1FRERkaib9++sFgsNfKducvdGnRdx/79+5GSkoKWLVuia9eu5b7TMlJKbNu2DXl5eejXrx+aNGlSYR6bzYadO3ciLy8Pbdq0QUJCgke1Xe17rszVavj1OhIdHX3Vz1Tm4sWL+PrrrwEAP/74o2v64MGDy83nzvd0LetHZmYmFi9ejDfeeAONGzcGAISFheHhhx/GrFmz8MYbbyAyMvLKX44HriWL3NxcbN++HQ0aNMCgQYOQkZGBrVu34qabbkJQUFCFLLZv346MjAzceuutFf5uqGqZ7lqyZAnOnj2L22+//ap1VuVK61ZV60ePHj2wfv36CtMHDx6M6OhoAO6vD+7UOXnyZDz88MNYuHAhpk2bdqWvhMhYJBF5TU5OjgQgP/30UymllMePH5cA5EcffSQTExPliBEjZGxsrIyPj5c5OTnyu+++kwkJCXLkyJGyXr16ctKkSeWWV/b6Dz/8UA4cOFAOGzZMdujQQdavX1+uWLHCNd+WLVskALlr165yr1+0aJEEIDMzMyutLy8vT/bp00dGRkbKcePGyf79+8t27drJzZs3u5axd+9e2a5dOxkdHS3HjBkjY2NjZceOHWVycrJH31VeXp68dOmSW/O6W8OePXtkfHy8DA8Pl6NGjZLdunWTAwYMkNnZ2VLK//99fvLJJ3LEiBGu7zMkJKTcZ5ZSyjVr1sjw8HDZpk0bOWLECFm/fn2ZmJgoz58/X+3a3PmeK+NODdX5TL+Wnp4ux48fLwHIfv36yaSkJJmUlCT37t1brWVe6/qxePHiStfZnTt3SgDyiy++uOLr4+Li5K233ipXrFghV65cKVNSUq44f5lrzeKLL76QwcHBslOnTnLYsGFyyJAh8l//+pcEIFNTU6WU5bfXoUOHymHDhsnbbrtNSllx25NSyiVLlsh69erJjh07ymHDhsnBgwdXWGZVRo8eLW+44YYK091d5tXWrarWj7Vr11a53kjp/vpQnc9+0003yUGDBl3x+yAyGjbgRF5UVQPes2dP+csvv0gppbxw4YKMiYmR99xzj7zjjjtkSUmJlFLK1atXSwBy06ZNruWVvb5z587y4MGDUkopdV2X06ZNk40aNZJ5eXlSymtvwP/85z/LmJiYco1wamqq3Lhxo5RSyvPnz8uIiAg5fvx4WVRUJKWUsri4WI4YMUL26tXLo+9q9OjRMjExURYXF19xPndryMnJkU2aNJFjxoyRFy9edE3fvn276x//su+ze/fu8qeffpJSSulwOOSQIUNk7969y30HISEh8o477pBOp1NKKeWJEydkRESEnDhxYrVru9r3XBl3a3D3M1X1HgDkokWLyk13d5merB9//etfJQCZlZVVbnpmZqYEIF966aUrvj4uLk5GRkbK0aNHy549e0pN0+SUKVNkYWHhFV93LVmcPXtWhoSEyEceecQ17aeffpIJCQmVNuBdunSRhw4dKreM3257586dk/Xr15cPPviga559+/bJTp06XbUBt9vtMiQkRD7zzDPlpru7THfXrarWj6qmu7s+VPezv/zyy9Jqtbr9g53ICNiAE3lRVQ34E088UW6+6dOnSwBy9+7drmm6rsvGjRvLZ5991jWt7PW//odKyssNgZ+fn3zzzTellNfegE+bNk22a9dOOhyOSj/P/PnzJYAKexe3b99e6ftVx6ZNm2RgYKAcP368tNvtVc7nbg2vvfaaFELI06dPV7mssu/zscceKzf9ww8/lABkQUGBlFLKF198UWqaJjMyMsrN9+KLL0ohhExPT69WbVf7nivjbg3ufqbKXK0Bv9oyPVk/nnnmGQlAXrhwodz0goICCUDOnj27ytdKKeWyZcvKfZ+rV6+Wfn5+8p577rni664li1deeUUGBAS4fvCWmTFjRqUN+IwZMyos47fb3quvvir9/f0rHFF54IEHrtqAnz59WgKQ//rXv8pNd3eZ7q5b1W3A3V0fqvvZv/jiCwlAHjhwoMrvhMhoeA44kQF06dKl3OOoqCgIIdC5c2fXNCEEIiMjkZGRUeH1PXr0KPc4PDwcMTExOHLkiEd1JSUlYcGCBejcuTOSkpKQmJiI/v37u87X3LVrFxo2bIht27aVe93FixcBAIcPH0avXr0qXfa2bduQmpp6xfe/5ZZbsHDhQtx5551YuHBhpedqu1vDnj17EBUVhdjY2Kt+7m7dupV7HBMTAwBIT09HgwYNcOjQIURHRyMqKqrcfD179oSU0vW8u7Vd7XuujLs1uPuZrsXVlunJ+uHv7w/g8sWEv1b2+GrnZE+YMKHc41GjRuGOO+7Ap59+irfffhshISGVvu5asjh69ChatGhRYbSR327XZbp3737F2suWGRsbW+6aDXdfWzZKyG/rcXeZ1V233OXu+lDdz142X3VHcSHyJTbgRAZQv379co+tViv8/f0rNBlWqxUlJSUVXl/ZBZRBQUEoKioCAGja5RFHpZTl5iktLb1iXYmJidizZw8WLFiApUuXYs6cOYiJicHChQsxePBgFBcXQ0qJ5cuXV3htUlLSFf+R3rVrF3bs2HHF9y8bMm7Xrl3Qdb3SJsjdGkpLS90eDeK3DanVagUA13dvt9srXVbZKAxl36u7tV3te66MuzW4+5muxdWW6cn60axZMwBAdna26yLMsscArqkB7Nq1KxYsWIDU1FR06NCh0nmuJQubzVblNliZsLCwq9ZaVFRUrWX+WtmPi8LCwmtaZnXXLXe5uz5U97OXfc6qflQRGREbcCIFJCcnl3vscDiQkpKCyZMnAwCaNm0KoOIeot++rjJdunTB/PnzAQCnT5/GhAkT8Ic//AGHDx9G69at4XA4sHDhwmqPejJz5swrPn/u3DkMHDgQzZs3x/r166tcvrs1xMXF4ZtvvoHNZvN4WLbY2FisXr0apaWlrj21AHDixAkAcA0lV53v50rfsyc1eKKyIw7V4cn6UbZnfP/+/eWa5bKb8VS15/xKsrKyAKDCntXfqm4WrVu3xpo1a6DruuvHbtlrK+PO99q6dWusXr0aTqez3HfnzjbbrFkzWCyWCjfgcXeZ7q5bVX2Oqqa7uz5U97OXfU5fDJVJdK14Ix4iBXz55Zfl9mQuXLgQNpsNkyZNAgDX4fFNmza55rHZbPjqq6+uuNzf3pWvZcuW6N+/v2uP0x133IHi4uJKx1rOzMyscPpAdUydOhV5eXlYt27dFU8bcbeGqVOnwuFw4PXXXy83j81mc+vGLr82ceJE2Gw2fPzxx65pDocD77//PuLj412nDrlb29W+Z09q8ETZntrqfj9lPFk/unXrhi5duuCDDz4oN/2DDz5Aly5d0LVrV9e0lStXYsOGDa7H2dnZFfbS5uXl4eOPP0avXr2uOHzhtWRxyy23ID8/H//5z39c00pKSso9rq5bbrkFBQUFWLJkiWuaO9ssANSrVw/dunWrcKMkd5fp7rpV1fpR1XR314fqfvZdu3YhPj4eERERlT5PZETcA06kgAkTJmD06NGYNGkS0tLS8MYbb+Chhx5y/UPp7++Pxx9/HH/5y19gtVoRERGBFStWICkpCc8991yVy3355Zfx888/Y8SIEWjevDmOHj2KDz/8EK+99hqAy3sK//a3v+HRRx/Fzp07MXjwYJSUlGDv3r3YunUrDh065DotobrmzJmDoKAgxMfHX3E+d2vo2rUrXn/9dTz++OM4fPgwhgwZgrNnz+KLL77AkiVL0LBhQ7drGzhwIGbOnIkHH3wQx44dQ5s2bfDll1/iyJEjWLt2rWsPoLu1Xe179qQGTwQGBqJfv374+9//DqvViuDg4CpPw6iMp+vHv/71LyQmJiIpKQmjR4/GqlWrsHv37nLNNgA8/PDDiImJQWJiIoDL5zA/9NBDuPnmm9GmTRtkZWXh/fffBwAsWLDgijVfSxY9evTA/fffj7vuugsHDx5EVFQUli9fjvHjx+PgwYPXlEXZMu+++27XOddfffUVJk6cWOWe+F+7+eab8cYbb5Tbi+3uMt1dt6paP6Kjoyud7u76UJ3PLqXEhg0bcNttt1X7OybyJe4BJ/Ki397trn79+khKSnJdvFamY8eOrtNHfm3UqFHo169fhek9evTAm2++iWPHjiE7OxuffPIJ3nrrrXLzzJ49Gx9++CHS0tJw+vRpvPfeexg+fDiSkpJcp2T8tr53330Xr7zyCkpKSrBp0yYIIbB161Y8/PDDruVOnz4dP/30E+Lj4/Hjjz/izJkzGD58OA4fPuzRnemuu+66cns5r8TdGmbOnIm9e/eiZcuW+PHHHyGlxDfffIP27dsDqDqPpk2bIikpqdypC/Pnz8e3336L0tJSbN++Hddffz1+/vnnCvm4U5s733Nl3KmhOp+pMkuWLMHNN9+M77//HsuXL0d2dna1lunJ+tGnTx8cOnQI7dq1w/fff4/4+HgcOnQIffr0KTffuHHjMGzYMNfjYcOGYdOmTQgPD3e95+zZs3HkyJGrHhm41izee+89fPDBB8jIyMDx48fx5ptvus5pLjtXvqrvDaj8TpjvvfceFixYgMzMTPzyyy945513cOONNyIpKemq3920adNQWFiIb7/9tkKd7izT3fW7svXjStPdXR/crXPz5s1IS0vDAw88cMXvg8hohPztVVlEVGecOHECbdu2xbJlyyqM+kBE3pOTk4Pw8PBy00aMGIGsrCwcPHjQJzX93//9H7Zt24bt27f75P29YcyYMWjevLnrCAdRXcFTUIiIiDz017/+FdnZ2Rg0aBAcDgeWLl2KH3/80XW7dl/405/+hBkzZiA5ORmtW7f2WR21JTs7G6GhoXjhhRd8XQpRtXEPOFEdlp2djUcffRRPPPHENY0KQUQ1Q9d1LF26FFu3bkVeXh7i4uJw2223oU2bNr4ujYgMiA04EREREZEX8SJMIiIiIiIvYgNORERERORFbMCJiIiIiLzIFKOg6LqO/Px8BAYG1sjNKYiIiIiIfktKieLiYoSGhkLTqt7PbYoGPD8/33VrXCIiIiKi2pSbm4vGjRtX+bwpGvDAwEAAl7+Msjv+eYOUEtnZ2YiIiOCed4WVOh14cc8GPNszEf4WU2xSpsSc1ceMzYE5m4OvejCbzYawsDBX71kVUwxDaLPZEBwcjKKiIjbgVOOYszkwZ/UxY3NgzubgywbcnZ6TF2ESecgpdfx06RycUvd1KVSLmLP6mLE5MGcyAjbgRB7SpcShi+egq38wydSYs/qYsTkwZzICNuBEHrJqFkyJag+rZvF1KVSLmLP6mLE5MGcyAp9cfXD48GF88sknrsf3338/WrdufcXXFBYWYtGiRUhNTUVCQgImTpx4xeFdiLzFqev4/nwKbg0Ph5+Ff6GrijmrjxmbA3MmI/BJB2u1WhEaGoqQkBC88sorSElJueL8Fy9eRJ8+ffDBBx+guLgYTz31FCZNmuSlaomuTueRTFNgzupjxubAnMnXfLIHvG3btnjqqadQXFyMP/3pT1ed/29/+xtKSkqwadMmBAQE4OGHH0arVq2wYcMGJCYmeqFioqpZNA2JYS1g4REZpTFn9TFjc2DOZAR1YgDMdevWYcKECQgICAAAxMTEoH///li7dm2lDbjdbofD4XA9ttlsAC4PSePNURfL3s8EIz2aWmFxKb7IPIrpTcJg5ZiyyrI7Hfgi8xhzVhgzNgfmbA6+6sHcfb86sealpaVh3Lhx5aY1a9YM6enplc4/d+5czJkzp8L07Oxsr48Dnp+fDwAca1RhU1/Iwg0jApATkcM9Kgpz6jpaiEDknGXOqmLG5sCczcFXPVjZTt+rqRMNuBCiwi8KKWWVF2HOnj0bs2bNcj0uuytRRESE1xtwABzsX3UyG6WZjREVGcmcFSalxHVCcHtWGDM2B+ZsDr7qwZRqwJs3b17hQs3U1FQMGjSo0vmtViusVmuF6UIIr29sZe/JjVxdQtOR3/4EHDIO/lqd2KToGth1J/6euh9/bjqcOSuKGZsDczYPX/Rg7r6XIY+9HDx4EE899ZTr8ZgxY7B8+XIUFhYCAE6cOIEdO3ZgzJgxviqRyEXqAvVPx8AiDLk5UQ2xCA2TItoxZ4UxY3NgzmQEPln78vLy8NRTT7lGQPnnP/+Jp556CgcPHgRweZzwV155xTX/9OnTER4ejn79+uEPf/gDhgwZgttvv73KPeBE3mYp9QePcahNAGhsDWTOCmPG5sCcyQh80oBrmobQ0FCEhYXhpZdeQpcuXRAaGuo6baRr16546aWXXPMHBQVh27Zt+NOf/oT4+Hh89NFH+Oijj3xROlEFwiJxvvMvsOu6r0uhWmTXdbx2ejdzVhgzNgfmTEYgpAnGyLPZbAgODkZRUZHXL8LMzs7mhR6KS5yxHwO7BOK5+9vx7qwK03UdmdlZiIqIZM6KYsbmwJzNwVc9mLs9J9c8ohrgCC6G8r9kTU4CyCopZM4KY8bmwJzJCNiAE3lIaBKXmmfCKXk4U2VOqePrnGTmrDBmbA7MmYyADTiRh6SuIfRYa1g1i69LoVpk1SyY3rwrc1YYMzYH5kxGwAacyFNCorhxPvemKM4pdey7cJY5K4wZmwNzJiNgA07kISEAe0ghdPWvZzY1XUok2/KZs8KYsTkwZzICNuBEHpK6QP2UZjycqTirZsEtEe2Ys8KYsTkwZzICNuBEntIkCqOz4eCYskpz6Dq+O3eaOSuMGZsDcyYjYANO5CkJCKfGu6opTgAI1PyYs8KYsTkwZzICNuBEnpICwdnhsPCGDkqzaBoGN45hzgpjxubAnMkIuPYReUhoEhdapcCuO31dCtUiu+7EwowjzFlhzNgcmDMZARtwIg9JCQTkhsIiuDmpzCI09GjQlDkrjBmbA3MmI+DaR+QpKeBf0ACa4BmFKtOEQIeQMOasMGZsDsyZjIANOJGHhEVHfsfjKHXycKbKSp1OzD+9hzkrjBmbA3MmI2ADTuQh6RSof7IF/HhBj9L8NA13RndkzgpjxubAnMkIuPYR1QDhtHBIK8UJAIEWDl2mMmZsDsyZjIANOJGHhEWioOMJ2HlTB6XZdR1vn9nHnBXGjM2BOZMRsAEn8pB0amh0sD38Lbytscr8LRY83boPc1YYMzYH5kxGwAacyFNCwh5SCF1KX1dCtUiXEqdsBcxZYczYHJgzGQEbcCIPCSFhiz4Lp+ThTJU5pY4NuSnMWWHM2ByYMxkBG3AiD0ldQ4NfWsGq8XCmyqyaBffFJDBnhTFjc2DOZARswIk8JSSKm5zn3hTFOaWO/xZkMWeFMWNzYM5kBGzAiTwlAGdQMXg6odqkBLJKCpmzwpixOTBnMgI24ESe0gXqpUbzpg6K89M0jG8ax5wVxozNgTmTEXDtI/KUJlEYkwkHx5RVmkPX8W1OMnNWGDM2B+ZMRsAGnMhTErCU+POuaooTABpbA5mzwpixOTBnMgI24ESekgKBOWGw8HCm0iyahn6h0cxZYczYHJgzGQHXPiIPCU3HhTanYdedvi6FapFdd2JB+k/MWWHM2ByYMxkBG3AiD0kpEJjVBBbBzUllFqFhUKMY5qwwZmwOzJmMgGsfkaekgPViCDTBMwpVpgmBNsGhzFlhzNgcmDMZARtwIg8Ji478hGModfJwpspKnU68emoXc1YYMzYH5kxGwAacyEPSKdDgaGuOKas4P03DH5p3Yc4KY8bmwJzJCLj2EdUAKXhLNTPQGbPymLE5MGfyNZ814AUFBfjb3/6GWbNm4bPPPoPzKoeC0tLSMH/+fDz99NP45z//iYsXL3qpUqIrExaJi/GneVMHxTl0Hf9OO8ScFcaMzYE5kxH4pAEvKChA7969sWTJEgQGBuLFF1/ETTfdVOX8+/fvR7t27bBr1y40aNAAn332Gbp27Yq8vDwvVk1UOenUEHqoHfwtFl+XQrXI32LBE616MWeFMWNzYM5kBD5pwN955x0IIbBu3TrMmTMH33//Pb777jusXbu20vk/+eQT9O3bF59//jmefvpprF+/HgUFBVizZo2XKyeqhJAobXARuuQxTZXpUuKXwjzmrDBmbA7MmYzAzxdvun79eowfPx5WqxUAEBUVhQEDBmD9+vUYOXJkhfnDw8NRVFTkelxSUgK73Y6mTZtWuny73Q6Hw+F6bLPZAABSSkgvbnBl7+fN9yTvEwIoaXoeTt3JYa0U5tSd+DE/A9fpbZizopixOTBnc/BVD+bu+/mkAc/IyECzZs3KTYuOjkZGRkal8z/66KP45ZdfMHjwYHTs2BE7d+7Ek08+icTExErnnzt3LubMmVNhenZ2NoKCgjz/AG6SUiI/Px8AILiRK0vqAv6Ho5CbcI45K0xKifHB0cjNYc6qYsbmwJzNwVc9WNlO36vxSQMuhKhw0aXT6YSfX+XlHDp0CFu2bMH111+Pli1bIj09Hd988w3uu+8+REZGVph/9uzZmDVrluuxzWZDWFgYIiIivN6AA0BERAQ3cpWJLOgxF9AkvAP8eE6hshxOJ7bnZ2B8eFvmrChmbA7M2Rx81YMZugGPjY1FSkpKuWkpKSkYOnRopfM//vjjGD9+PN544w3XtEGDBmHevHmYN29ehfmtVqvr9JZfE0J4vREue0824AoTgPR3AMxZbUKgwFHKnFXGjM2BOZuGL3owd9/LJxdhjh07FkuXLnUNJXj06FHs3LkTY8eOBQDs27cPM2fOdM3v5+dXbthBXddRWFhYaZNN5HW6QFBaJG/qoDg/TcOY8FbMWWHM2ByYMxmBT9a+Bx54AC1atEDv3r1x99134/rrr8d9992H/v37AwCOHTuGt956yzX/7NmzsWjRIowYMQLTp09Hr169kJOTg+nTp/uifKLyNImi2AyOKas4h65jefYJ5qwwZmwOzJmMwCenoAQGBmLz5s1YvXo10tLS8Pvf/x6DBg1yPd+jRw/Mnz/f9Xj48OE4ffo0vv/+e+Tm5mLs2LEYPnw4AgICfFE+UXkSsBQGgUcy1SYE0CwwhDkrjBmbA3MmI/BJAw5cPq1k3LhxlT7Xrl07tGvXrty0Jk2a4NZbb/VGaUTVIwUCckJhETycqTKL0NC7YSRzVhgzNgfmTEbAtY/IQ0LTcbH9Kdh159VnpjrLrjvxr7SDzFlhzNgcmDMZARtwIg9JKRCUFsG9KYqzCA0jwloyZ4UxY3NgzmQEXPuIPCUF/C4F845qitOEQGxQA+asMGZsDsyZjIANOJGHhEVHQbdjKHXycKbKSp1OzE3eyZwVxozNgTmTEbABJ/KQdArUP9QGVo4pqzSrpuGx2B7MWWHM2ByYMxkB1z6iGiCtDkhfF0G1SgIodNqZs8KYsTkwZzICNuBEHhIWicI2qbypg+Icuo7PM48yZ4UxY3NgzmQEbMCJPCSdGhr81Ab+FouvS6Fa5G+x4NHYHsxZYczYHJgzGQEbcCJPCYnS0AtwSu5NUZlT6jh8KZc5K4wZmwNzJiNgA07kISGA0rAC6JJnFKpMlxL7L55lzgpjxubAnMkI2IATeUjqAvVONodV4+FMlVk1C26L6sCcFcaMzYE5kxGwASfylJAojjoHJy/oUZpT17HpfCpzVhgzNgfmTEbABpyoJmj8i9wM7DxnVHnM2ByYM/kaG3AiT0mBwPSmsPCmDkqzaBqGh8UyZ4UxY3NgzmQEXPuIPCQ0iaJW6bDrvK2xyuy6E19l/cKcFcaMzYE5kxGwASfykJSAX0EINCF8XQrVIk0ItKvXiDkrjBmbA3MmI2ADTuQpKWDNbQiL4OakMovQ0LV+OHNWGDM2B+ZMRsC1j8hDQtNxqWMyD2cqzq478Y+U/cxZYczYHJgzGQEbcCIPSV0g6HQU96YoziI0TGjahjkrjBmbA3MmI+DaR1QDNFsAeDah2gSAcP9g5qwwZmwOzJmMgA04kYeEReJS9+Ow86YOSrPrOl49vYs5K4wZmwNzJiNgA07kIekUCNnXFlaOKas0q6bhyZa9mbPCmLE5MGcyAq59RDVADyqB9HURVKskgJzSIuasMGZsDsyZjIANOJGHhCZha5kJJ29trDSn1LH87AnmrDBmbA7MmYyADTiRh6SuIeRwa1g1i69LoVpk1SyY0aIbc1YYMzYH5kxGwAacyFNCwt64gHtTFOeUOg5czGHOCmPG5sCcyQjYgBN5SAjAEXoJuuQZhSrTpcQvhXnMWWHM2ByYMxkBG3AiD0ldICi5GQ9nKs6qWXBrZDvmrDBmbA7MmYyADTiRp4REcbOzcHJMWaU5dR3rcs8wZ4UxY3NgzmQEbMCJaoDQuSmZgZW3rlYeMzYH5ky+xjWQyFNSICCzCSy8qYPSLJqG6xs3Z84KY8bmwJzJCLj2EXlIaBJFbVJh152+LoVqkV134vPMI8xZYczYHJgzGYGfr974/Pnz+PDDD5GamoqEhATcddddsFqtV3zNpk2bsHbtWgQHB+Pee+9Fs2bNvFQtUdWkBPzONYQmhK9LoVqkCYFu9ZsyZ4UxY3NgzmQEPtkDnpeXh169euG7775DZGQk3nrrLYwdOxbyCkMCPfjgg5gyZQo0TYOfnx9uvPFG5OXlebFqoipIAWteA1h4TqHSLEJDx5Aw5qwwZmwOzJmMwCd7wN9++20EBgZi1apV8PPzw+9//3s0b94cq1evxpgxYyrMv3LlSnz88cc4evQoYmJiAAAPPPAAAgICvF06UQXCoqMw4QRKnW0Q4Oezg0pUy0qdTrx1Zi+ebzKCOSuKGZsDcyYj8Mmat3HjRowbNw5+/1vxmzZtigEDBmDjxo2VNuCfffYZJk6ciH379uH1119Hs2bNcMcdd6Bx48aVLt9ut8PhcLge22w2AICU8op72Wta2ft58z3J+6RTIPB4c1gGCWatMIsQmBIZD4tgzqpixubAnM3BVz2Yu+/nkwY8MzMTUVFR5aZFR0cjIyOj0vlPnDiBvLw8ZGRkYPTo0di2bRteeukl7N27F7GxsRXmnzt3LubMmVNhenZ2NoKCgmrmQ7hBSon8/HwAgOC5Zkpz2nSczc6GxqvqlaXrOpyXbMxZYczYHJizOfiqByvb6Xs11W7At2/fjvfffx8ff/yxW9Mro2kanM7yVx87HI4qL8IUQkDXdaxZswZ+fn54/PHHcd111+HNN9/E/PnzK8w/e/ZszJo1y/XYZrMhLCwMERERXm/AASAiIoINuMKEJROlPVPQuGlnBFh4OFNVJU4HXjq9C6/FxzNnRTFjc2DO5uCrHqzWGvCioiKkp6dXmF5QUIBz5865tYzY2FicPn263LTTp09j2LBhlc7fsmVLhIWFuU5ZAYCOHTsiNTW10vmtVmulzbwQwuuNcNl7sgFXl3RqCNkbj4D+fsxZYQEWP8xu3RcBFuasKmZsDszZPHzRg7n7Xm4fe0lJScG8efPw1Vdfuf5c9t8rr7yCuXPnokOHDm4ta9y4cVi6dKnr0MBPP/2EXbt2Ydy4cQCA3bt34w9/+INr/ptuugl79+51zV9aWopt27ahW7du7pZPVHuEhDOkCDrPJVSaLiXO2C4wZ4UxY3NgzmQEbjfg58+fx/r167F3717Xn8v+27p1K6677jo888wzbi3r/vvvR7t27dCzZ0/87ne/w/XXX4+HHnoIffv2BXD5nO/333/fNf/UqVMxYMAAdO3aFXfeeSe6dOmCRo0a4bHHHqvmxyWqeUJIlDTPhlPqvi6FapFT6vgu9zRzVhgzNgfmTEYgZDUvDz127BjWrVuHhx56yKM31nUdGzZsQFpaGjp37ozevXu7njt58iTWrVtXbi84AGzZsgUnT55Ey5YtMXjwYLcvnrDZbAgODkZRUZHXzwHPzs7mOeCKS5xxAL07BOClh+KZs8K4PauPGZsDczYHX+Xsbs9Z7XPAW7RogVGjRuHEiRMVngsODkZ0dLRby9E0DcOHD6/0ubi4OMTFxVWYPmjQIAwaNKh6BRPVNiFhD8+DU+rwExZfV0O1xCl17CrIwuim4cxZUczYHJgzGUG1G/Bt27ZV2TgnJiZi/fr1HhdFVKcIwBliA08nVJuUQHrxJeasMGZsDsyZjKDaA2DecMMNsNlsrv+Kioqwe/du9OzZE2+//XZt1EhkbLpA4Klo+HE8WaX5aRomRLRhzgpjxubAnMkIqr32aZqGwMBA139BQUHo2bMnHnnkEbz77ru1USORsWkSJS2y4NB5QY/KHLqOVTmnmLPCmLE5MGcyghr7+efv74+0tLSaWhxR3SEBUWoFL+VRmwDQ0M+fOSuMGZsDcyYjqPY54NnZ2fj+++/LTcvNzcW8efMwY8aMGiuMqM6QAv5ZYbDwcKbSLJqGAY2aMWeFMWNzYM5kBNVuwE+fPo2XX3653LTQ0FDcd999mDlzZk3VRVRnCE3CFp8Cu94G/rytsbLsuhMfp/+Mx8KbMGdFMWNzYM5kBNVe8/r27Yv9+/fXQilEdZOUgDWzMSyCe1NUZhEa+oVGM2eFMWNzYM5kBNf802/z5s1Yt24dCgoK0L59e9x1110ICQmpydqI6gYp4FcQAo03dFCaJgTa1WvEnBXGjM2BOZMRXNPPv6eeegqjRo3CoUOHUFBQgHfeeQcdOnRAZmZmTddHZHjCoqOw23GUOp2+LoVqUanTiXmndjNnhTFjc2DOZATV3gOekZGBd955B3v37kWHDh0AXL6t/NSpU/HKK6/gzTffrOkaiQxNOgWCDreE30AezlSZn6bhvpgEjh2sMGZsDsyZjKDaa19aWhoSEhJczTdweWzwyZMnIzU1tUaLI6ozeEc1U9B4xFp5zNgcmDP5WrUb8I4dOyI9PR05OTnlpv/www/o3bt3jRVGVFcIi4StM2/qoDqHruO91IPMWWHM2ByYMxlBtU9BycvLQ+fOndGzZ09MmTIFDRs2xI4dO7Bx40Y899xzrlNQWrRogYkTJ9Z0vUSGI50a6u1rB/+BFl+XQrXI32LBk616w9/CnFXFjM2BOZMRVLsBP3fuHOx2O9q1a4c9e/a4pl933XVYu3at63GPHj3YgJM5CAlHg0vQpYSFV9UrS5cSJ4ryES6bMmdFMWNzYM5kBNVuwLt3747169fXRi1EdZIQEvboXDilDsu1DSxEdYBT6tiSl4Y+sW2Ys6KYsTkwZzKCaq9527dvx1133eX2dCLVSV1D4NFYWDUezlSZVbPgnmadmbPCmLE5MGcygmo34EVFRUhPT68wvaCgAOfOnauRoojqFCFhj8yFkxf0KM2p6/gxP4M5K4wZmwNzJiNw+xSUlJQUfPnllzh+/DhSUlIwb94813NOpxMrV67EddddVytFEhmaAPQAO0ciVJwEcN5ezJwVxozNgTmTEbjdgJ8/fx7r169Hbm6u689lrFYrrrvuOjzzzDO1UiSRoekCAWcieVMHxflpGsaGt2bOCmPG5sCcyQjcbsC7deuGNWvW4NixY1i3bh0eeuih2qyLqO7QJEpaZsKht4WVw1opy6Hr+PrsSdwTHs6cFcWMzYE5kxFUexSUFi1aYNSoUThx4kSF54KDgxEdHV0jhRHVGRLQigLB0azUJgQQGVCPOSuMGZsDcyYjqHYDvm3bNgwfPrzS5xITEzlEIZmPFLCebQSL4OFMlVmEhj4NI5mzwpixOTBnMoJqr3033HADbDab67+ioiLs3r0bPXv2xNtvv10bNRIZmtB02Dqchl13+roUqkV23Yl/px1izgpjxubAnMkIqt2Aa5qGwMBA139BQUHo2bMnHnnkEbz77ru1USORoUkp4J8azr0pirMIDYlhLZizwpixOTBnMoIaW/v8/f2RlpZWU4sjqjukgOViPWg8oVBZUkqMeOgQoiz1mbPCNCHQKqghM1YccyYjqPY54NnZ2fj+++/LTcvNzcW8efMwY8aMGiuMqK4QFh1FPY+h1NkGAX7V3qSoDtDl5ZzfSNuN16LHMGdFlTqdeCn5v3i1CTNWGXMmI6j2mnf69Gm8/PLL5aaFhobivvvuw8yZM2uqLqI6QzoFgg7EwdqfhzNVJp0Ct4d2gZVjByvLqml4JLY7M1YccyYjqHYD3rdvX+zfv78WSiGqu6SfzruqmUCJdDJnhUkAxU4HM1YccyYjuOaff0VFRdi5cyfWrl2LM2fO1GRNRHWKsEgUt0+BQ9d9XQrVImGR+PrCUeasMIeu45OMw8xYccyZjOCaGvCNGzeiTZs26N+/P26++Wa0atUK9913H3SuzGRC0qkheH8b+POOakqTTg13NurGnBXmb7HgsZY9mbHimDMZQbUb8OLiYtx222148MEHUVhYiKKiIuzZswebN2/Gv//979qokcjYhISj0UXokgc0lSYkkkvPM2eF6VLiyKVcZqw45kxGUO0G/MiRIwgPD8fs2bMRGBgIAOjevTuef/55bNy4scYLJDI6IQBH03w4JY8AqUrgcs6Hi3OYs8KcUsfeC2eZseKYMxlBtRtwq9WK4uLiCtNtNhusVqvby8nKysLzzz+P3//+93jzzTdhs9ncet2WLVtw++23Y9WqVW6/F1FtkrpAwLHmsGo8nKkyqQvc2CCeOSvMqlkwNboDM1YccyYjqHYDHh8fD13XMWPGDCQnJ+P8+fNYtWoVnnvuOdx4441uLSMnJwe9evXC/v370a1bNyxcuBAjR4686jnkFy9exLRp07B69WocPny4uqUT1Q4hYY8+ByevgVCbkNhdlM6cFebUdfxwPo0ZK445kxFc0x7wJUuWYNu2bYiLi0NYWBgmTpyIadOmISkpya1lvP3222jcuDGWLl2Khx9+GN999x127dqFlStXXvF1M2fOxF133YWoqKjqlk1UewQg/Tg8nfIEUMphCJUmARTrHJ5OdcyZjOCabgHVvXt3HDhwAJmZmSgoKECrVq0QEBDg9us3bdqEsWPHQvvfIPiNGjXCgAEDsHnzZtx0002VvmbVqlU4cOAA3n//fSxcuPCKy7fb7XA4HK7HZae3SCkhvXjRRdn7efM9yQd0Af8zTWERglkrSkoJ6AL9gpszZ4VZhMDwsFhmrDjmbA6+6sHcfT+P7sEaFRV1TXujs7KyEBkZWWFZWVlZlc6fl5eHGTNm4Ouvv4afG7eNnTt3LubMmVNhenZ2NoKCgqpd77WSUiI/Px8AIITw2vuSdwlNorh1GtKzGvCcQkXpUkJoEqvzjqFRlmDOirLrTixJP4pJUmfGCmPO5uCrHszdaxo9asCvlcVigd1uLzettLQU/v7+lc7/4IMP4u6770aXLl3cWv7s2bMxa9Ys12ObzYawsDBERER4vQEHgIiICDbgCpMyC34XQxAZEQE//mWuJF2XkDIbLYMaM2eFOXQn4i+eY8aKY87m4KsezNANeOvWrZGcnFxu2qlTpzB69OgK8+bk5GDRokWYPHkybr/9dgBAWloaFi1ahLy8PMydO7fCa6xWa6UjsgghvN4Il70nG3CFSQG/c43gp1mYs6KEACAFOgSGM2eF+WkW9GgYwYwVx5zNwxc9mLvvdc23ovfEhAkTsHTpUpw7dw4AsGfPHuzevdt1/veOHTtczXb9+vXx6aefYty4cRg1ahRGjRqF+vXrIz4+HgMGDPBF+UTlCE1Hcedk2HWnr0uhWiQ0HV8WHGLOCrPrTrybeoAZK445kxH4ZA/4vffeixUrVqBr167o3r07tm7diqeffho9evQAAJw+fRoLFy7EZ599hsDAQFczXubll19Gjx49MGbMGF+UT1SO1AWsyVGwDPXJ71nyEqkLDKnXChbBnFVlERrGh7dmxopjzmQEPmnA/fz88M0332DHjh1IS0vDa6+9hg4dOrie79evHz799NMqX//yyy8jLi7OG6USuUUUBYIHMtUXbglmzgoTACID6jFjxTFnMgKfNODA5XNk+vXrV+lzsbGxiI2NrfK17t7wh8gbhEWipPcvsOttEaBxj4qqhEXig/y9mKdHMWdF2XUdL5/ahXnhY5mxwpgzGQHXPCIPSadAwO62sPIvcqVJp8Ddod2Ys8Ksmob/a9mLGSuOOZMRcO0jqgEysJR3VTOBAmcJc1aYBHDeXsyMFcecyQjYgBN5SGgSpW3T4ZS6r0uhWiQ0iXWFJ5mzwpxSx5LsX5ix4pgzGQEbcCIPSV1D4IE43lFNcVLXMKVhAnNWmFWz4KEW3Zmx4pgzGQEbcCJPCQlnWAH3pqhOSPxSksucFeaUOg5ezGHGimPOZARswIk8JATgbHwRuuQZhSoTAkguzWPOCtOlxJHC88xYccyZjIANOJGHpC7gf7wZD2cqTuoCI0PaMGeFWTULkiLjmbHimDMZARtwIk8JCXvzHDh1Hs5UmpDYaUtjzgpz6jo25KYwY8UxZzICNuBENYFHMk1B473zlKcxYlNgzuRrbMCJPCUFrGnhsPCmDmqTAr2DmjFnhVk0DUMbt2DGimPOZARc+4g8JDSJ0nZpsOtOX5dCtUhoEmsuHWfOCrPrTizKPMqMFcecyQjYgBN5SErAktsAmuAxTZVJCbTxD2POCtOEQEL9JsxYccyZjIANOJGnpIB2rgEsgpuT0qRAnH9j5qwwi9DQOaQJM1YccyYj4NpH5CGh6SjplszDmYoTmo7FBQeZs8LsuhNvn9nHjBXHnMkI2IATeUjqAtZjzbg3RXFSFxgR0oY5K8wiNCRFxjNjxTFnMgKufUQ1QJT6cYA6EwjRApizwgSAhlZ/Zqw45kxGwAacyEPCIlHa6yTsvKmD0oRF4tOC/cxZYXZdx+un9zBjxTFnMgI24EQekk4B/51tYeWYskqTToF7G/RgzgqzahqeadWHGSuOOZMRcO0j8pQAZEgxb4apOgFkOwuZs8IkgLSSS8xYccyZjIANOJGHhJBwtMqGU/JwpsqEkNhmO8OcFeaUOlblnGLGimPOZARswIk8JHUN/odawqpZfF0K1SKpa7ilfifmrDCrZsEDzbswY8UxZzICNuBEnhISjqb53JuiOiFxpCSHOSvMKXXsucCjWapjzmQEbMCJPCUA2aAIkicUqk0Amc6LzFlhUgJnbBeYseKYMxkBG3AiT+kCfiei4ccr6tWmCwwNbs2cFeanaZgY0ZYZK445kxFw7SPylCbhiM2Gg2PKqk2T+NGWwpwV5tB1rDl3mhkrjjmTEbABJ/KUBISdd8JUngSChJU5K0wAqGdhxqpjzmQEbMCJPCUFLBlhsPBwptqkQLfAKOasMIumYVCjZsxYccyZjIBrH5GHhCZh75AKu+70dSlUi4Qm8e2lY8xZYXbdiU8zDjNjxTFnMgI24EQekhKwZDWCRXBzUpmUQCf/COasMIvQ0KdhJDNWHHMmI+DaR+QpKaCdD4EmeEah0qRArDWUOStMEwLx9RozY8UxZzICNuBEHhIWHaU9T6DUycOZKhMWHZ9f3M+cFVbqdOKN03uYseKYMxkBG3AiD0mngPWnFhxTVnHSKXBjvfbMWWF+moa7m3VixopjzmQEfr5649TUVPz9739HamoqEhIS8NBDDyEkJKTK+VevXo1Vq1ahtLQU/fr1w9SpU2G1Wr1YMdEV6BqHtDIBPzBnlQkAVsGMVcecyQh88vMvKysLffr0walTp3D99dfj66+/xvDhw+Gs4nDQfffdh3/84x+Ij49Hly5d8MILL+CWW27xctVElRMWCXv3U7Dzpg5KExaJJZd+Ys4Ks+s6/pG6nxkrjjmTEfhkD/jbb7+NyMhILF68GEIITJ48GVFRUVixYgUmTpxYYf6//OUviI6Odj3u0aMH+vfvj/T0dDRr1sybpRNVIJ0a/P/bFv4DLL4uhWqRdGq4s0EP+FuYs6ouXtLR9WxnZqw4f4sFs1r1Yc7kUz5pwH/44QeMHj0a4n9XIDds2BADBgzAli1bKm3Af918A8CFCxegaRrq169f6fLtdjscDofrsc1mAwBIKSGlrKmPcVVl7+fN9yQfEBLOhoVw6jpv7KAoKSUgJNLsBeii82Y8qlq2KQcrD53F7TfGMmOFOXUdJwvz0UQPZ84K81UP5u77+aQBz87ORkRERLlpkZGRyM7OvuprL168iCeffBLTp09HgwYNKp1n7ty5mDNnTqXvGxQUdG1FXwMpJfLz8wHA9WOD1COEhDMmB5lZWbByj4qSdCkhhMSuolR0zwplzoq6VHQJTbvlcVtWnN3pxIZzp9EisD5zVpiverCynb5X45MG3M/PD6WlpeWmlZSUIDAw8Iqvu3jxIsaMGYOWLVvijTfeqHK+2bNnY9asWa7HNpsNYWFhiIiI8HoDDgARERFswBUm9WxYf26JZsOjmLOidF1C6mcxoUEnNItizqqqH6zj1OpoNBvLjFUmpcQ0TeO/zYrzVQ9m6AY8Li4OJ0+eLDft5MmTGD9+fJWvOX/+PEaNGoVWrVrhs88+u+IIKFartdLnhRBe39jK3pMbucKEhDMyD7qUHNZKUUIAEBI/l55FVxnNnFWlSTTuUMBtWXFOXcd/C7IwtmlT5qw4X/Rg7r6XT9a8m2++GUuXLkVWVhYAYMeOHdi3bx8mTJgAANi2bRsmTZrkmj87OxvXX389OnXqhM8//5zDD5KxCEAGl4Bn+itOAHlOG3NWmAQQGGpnxoqTAM6WFjFn8imf7AG/++67sWrVKnTt2hUJCQnYuXMnnn/+eXTt2hXA5THC//Of/7jmv/POO3Hs2DG0bdsWSUlJrukvvvgi2rdv7/X6icrRBfySI7knRXW6wMCglsxZYRZoyPixCfxuZ8Yq89M0jGsax22ZfMonDbjFYsF//vMf7Nu3D2lpaejUqRNat27ten7gwIH46quvXI+feuopTJs2rcJywsPDvVIv0RVpEo7WWXDo7XhBj8o0ia220+iiRzFnRenQEd3vHBy6zowV5tB1rDx7EneHhzNn8hmf3QkTALp3747u3btXmB4TE1PuFJShQ4d6syyi6pGAKArgXdVUJ4FGliDmrDABoDjfyowVJwA09Q9mzuRTPP5C5CkpYMlqxPFkVScFOvlHMGeFaULD+SMNmbHiLJqGvqEcz598i2sfkYeEpsPR+QzsutPXpVAtEpqOlYVHmLPCdOhoNTqDGSvOrjvxYfpPzJl8ig04kYekFBApTWAR3JxUJqVA94BmzFlhGgTO7m/EjBVnERqubxTDnMmnuPYReUoKaAX1oHGsd7VJgWZ+DZizwgQECjODmLHiNCHQOjiUOZNPsQEn8pCw6HD0PY5SJw9nqkxYdHx2cS9zVpgOHe1/d4YZK67U6cQrp/7LnMmn2IATeUg6BSx7W8HKC3qUJp0CE+t1Zs4KE0LgxIpmzFhxVk3DjObdmDP5FNc+oppg0XlXNRNwgDmrTlgkM1acBGCX3JbJt9iAE3lIWCScnVPg0HVfl0K1SFgkVhUeZc6KazU6kxkrzqHr+Cj9Z+ZMPsUGnMhD0qnBb3cb+POOakqTTg2/C+nGnBWmQcMvX7Vgxorzt1jwx5Y9mTP5FBtwIk8JCb3RJeiSBzSVJiRSHPnMWWESEvVjCpmx4nQpcazwPHMmn2IDTuQhIQA9Og9OycOZKhMCOFyazZxVJiQad7jAjBXnlDr+W5DFnMmn2IATeUjqAn4/N4dV4+FMlUldYFRwPHNWmAYNZ9ZFMWPFWTUL7ojuyJzJp9iAE3lKSOjNcuHkBT1qExIHSjOZs8Kk0NEkIZ8ZK86p69iSl86cyafYgBN5SgDS38EhrVQnAJu0M2fF+QU6mbHiJIBCJ7dl8i024ESe0gUspyLgx5s6qE0X6BvQgjkrTIOGrF1hzFhxuXkOdNNimDP5FNc+Ik9pEs62GRxTVnWaxObiZOasMB06mg08y4wVd+/co3hj/xHmTD7FBpzIUxIQF4IhhK8LoVolgUhLfeasMAGBouxAZqy4klLJnMnn/HxdAFGdJwW07FBYBH/PKk0KxFubMGeFaUIg73gDZqw6yZzJ97j2EXlIaDocXU/Drjt9XQrVIqHpWFH0M3NWmA4drW9MZ8aKExpzJt9jA07kISkFtJMR3JuiOCkFrvNvwZwVJiCQuTOMGStOSuZMvse1j8hTEsDFQPB0QsVJIFyrx5wVJiBgywlgxqqTYM7kc2zAiTwkLBJ6/+Ow84p6pQmLxGdF+5izwiQkOt5+hhkrTliYM/keG3AiD0mngLYzDlaOKas06RRICu7KnBUmhMDRL1owY8VJJ3Mm3+PaR1QTAngnTDMolCXMWXHWetyWVScEcybfYwNO5CGhSegd0uGUPJypMqFJbCw+yZwVJiHRYmg2M1ac0Jgz+R4bcCIPSV2DZU9rWDWLr0uhWiR1DbcEJzBnhVmEhuPLmjNj1enMmXyPDTiRp4SE3uQC96aoTkiccpxnzgqTkGjQ8hIzVp1gzuR7bMCJPCQEIMMvQJc8o1BlQgDJjvPMWWkSoa0KmbHihAbmTD7HBpzIQ1IX0I7E8HCm4qQukBjYhjkrTIOGlO8jmLHqdMGcyefYgBN5SkjoLXLg5JiyahMSe0vTmbPCdOho2i2PGStOaGDO5HNswIlqAm+pZgqSh6yVJgQAwYxVx5zJCNiAE3lKCmhnwmHhTR3UJgV6+McwZ4Vp0HB2X2NmrDopmDP5nJ+v3jg5ORlvv/02UlNTkZCQgMceewwNGzassfmJvEVoEnr7dNj1tvC3+GyTolomNInvi0+gux7FnBWlQ0fz67Nh153MWGHCItF8IHMm3/LJz7+MjAz07dsXeXl5mDBhAjZt2oTExEQ4HI4amZ/Im6QERG59aILnoahMSiDWrxFzVpiAwIUz9Zix6iSYM/mcT376vfXWW4iNjcXHH38MALj55psRGRmJ5cuXY9KkSR7PT+RVUkDkNIBF8HCm0qRAa7/GzFlhmtBQcCqEGStOSMGcyed80oBv2bIFI0eOdD0OCQnBgAEDsHXr1kob6urOb7fby+0dt9lsAC5fQOXNi6hSsopx6FgxQrMKwB/a6hKajtKuyfhhfwT8eE6hkqS8nPNXlw6hfkpDaNICXQecurz8n1PCqZef/1ePKkyr5OkK03nBp/f9dOoi2kxIxemsOOhODaV2iRK7DqdTQuJyhpf/k64/6//7M9UdpU4n2kxIx4n01rCXaigu1aHrEvr/stV15qqKsHoONG3q3SDd/bvbJw14Tk4OIiIiyk1r2rQpsrOza2T+uXPnYs6cORWmZ2dnIygo6Bqrrr4f9xdh4+5LsPgVcZAMhUld4Oz2cCz2z4Rg0sqSusDxdU3wfMlpaJoGiwZoGqBp4vKfBSr9oV1u0v9mEBUnoZLZuDZ5WU6BA0VnmuLRNSfhb9Xg7ydgtV7OV4jLefz//4vLf/7fY4ZVd0hdIG1zU8xadwqBARoCfp2xENDE5e0ZQv1YVf+NMbaPRGiIBcKLe0HLdvpejU8acKvViuLi4nLTiouLERwcXCPzz549G7NmzXI9ttlsCAsLQ0REhFcb8MkjJYZ0y0ZERIRXwyfv0nUdaVmZiImMgsY94MpizupjxubAnM1BSonsbO/3YIZuwOPi4nDixIly006ePIkJEybUyPxWqxVWq7XC9Mt7LLzbCJe9JxtwdTmkxLwzezAvYiwCmLOymLP6mLE5MGfz8EUP5u57+eSn36RJk7B06VKkp6cDuHyO94EDBzBx4kTX4xtvvNHt+Yl8yappeKpVb1i5J0VpzFl9zNgcmDMZgU/2gN9xxx1Yu3YtEhIS0LFjR+zfvx9//etf0blzZwBAeno6vv32W7fnJ/IlCSCrpBCRvi6EahVzVh8zNgfmTEbgkwZc0zR8/vnnOHLkCNLS0tChQwfExMS4nh88eDBWrlzp9vxEvuSUOr7OSUZC81aw8OayymLO6mPG5sCcyQiENMFYVzabDcHBwSgqKvLqRZi+ugCAvIs5mwNzVh8zNgfmbA6+vAjTnZ6TP/2IPOSUOvZdOAun1K8+M9VZzFl9zNgcmDMZARtwIg/pUiLZlg9d/YNJpsac1ceMzYE5kxGwASfykFWz4JaIdrBqFl+XQrWIOauPGZsDcyYj8MlFmN5Wdpq7u4Oj1+T72mw22Gw2nmemMLvTiW/SjmJySAisFv6FrirmrD5mbA7M2Rx81YOV9ZpXu8TSFBdhnj9/HmFhYb4ug4iIiIhMIDc3F40bN67yeVM04LquIz8/H4GBgV7/FRQWFobc3Fyvjr5C3sWczYE5q48ZmwNzNgdf5SylRHFxMUJDQ6Fd4WZPpjgFRdO0K/4KqW1BQUHcyE2AOZsDc1YfMzYH5mwOvsg5ODj4qvPwIkwiIiIiIi9iA05ERERE5EVswGuRn58fnnvuOfj5meJMH9NizubAnNXHjM2BOZuD0XM2xUWYRERERERGwT3gRERERERexAaciIiIiMiL2IATEREREXmRMc9Mr0NKS0uxdetWXLp0Cf369UN4eHiNzk/GkJeXh23btiEgIAADBw684piia9euRV5eXrlpw4cP591YDczhcGDJkiWux506dUJCQsJVX3fq1CkcOHAAkZGR6Nu3r1dv9EXVl5GRgR9++MH1eOjQoYiIiKhy/vT0dGzZsqXctKioKAwZMqTWaqSakZOTgz179qBevXro1avXVceBLvu3ubCwEP369UOTJk28VCl54uTJkzh8+DCio6PRo0ePK/4dvGbNGuTn55ebNnLkSDRq1KiWq6wcG3APZGZm4oYbbgAAREREYO/evfjss88wfvz4GpmfjGHTpk2YMGECEhIScOHCBRQUFGDDhg2Ii4urdP5Zs2YhKCgIsbGxrmm9evViA25gTqcTy5cvBwBs2LABDzzwwFUb8Ndffx3PP/88+vXrh8OHD6NDhw5YuXIlAgMDvVAxXYvs7GwsX74cUkp8+eWXWLdu3RUb8F27dmHatGkYO3asa1q3bt3YgBvcI488gmXLlqFz587IyMjA2bNnsXz5cvTt27fS+dPT03HDDTfAYrGgadOm2Lt3LxYtWlQudzKWs2fP4u6778bx48fRvn177Nu3D1FRUVi7dm2VN1584okn0KBBA7Ro0cI1rU+fPj5rwCHpmt11111yyJAh0m63SymlnD9/vmzSpIksLi6ukfnJ93Rdl61atZKzZ892PZ4wYYK88cYbq3xN165d5aeffuqtEqmGDRgwwJV3VY4fPy4tFotct26dlFLKvLw8GRsbK+fNm+eNEslDdrtdAnDlV5Vly5bJuLg4L1VFNeXf//63LC0tdT2+8847Zd++faucf+rUqfKGG26QDodDSinla6+9Jps2bSpLSkpqvVa6NsnJyXLNmjWux0VFRbJ9+/Zy1qxZVb6mU6dOctGiRd4ozy08B9wDy5cvx7Rp01xjTN53333Iz8+vcMjyWucn39u/fz9OnTqF6dOnAwCEEPjDH/6ANWvWoLi4uMrXHTt2DMuXL8fevXshOdKnclauXIlWrVph2LBhAIDQ0FBMmTIFy5Yt83FlVNNKS0uxatUqrF+/Hjk5Ob4uh9zw+9//Hlar1fW4a9euOHfuXKXz6rqOFStW4P7774fFYgEA3H///Th37hy2b9/ulXqp+lq1aoWRI0e6HgcFBaFt27ZV5lzm6NGjWL58Ofbt2+fzf5vZgF+j3NxcFBQUoHXr1q5pISEhCA8PR3JyssfzkzEkJyfD398fzZo1c01r1aoVHA4HUlJSKn3NqFGjcPz4cSxYsABjx45Fnz59kJWV5a2SyQuSk5PLbcvA5fWC27JaYmJi0L9/f3z88cd47rnn0LJlS7zzzju+LouqoaioCB9++CEmTpxY6fM5OTm4dOlSue25QYMGCAsL4/Zchxw9ehTr16+vMmcAGD16NI4ePYoPP/wQo0ePxnXXXYezZ896scryeA74NXI4HAAAf3//ctMDAgJcz3kyPxmDw+GoNLOy5yrz8ssvu/5ss9kwYsQIPPbYY1i0aFHtFUpeVdV6wW1ZLb169cLixYtdj1euXIkJEyZg2LBh6NChgw8rI3eUlJTg1ltvRZMmTfDCCy9UOg//ba77UlNTMWbMGDz66KMYM2ZMlfO99tprrj8XFRUhMTERjz/+OD799FNvlFkB94Bfo8aNG8NqtZbbs6nrOs6ePVvpRT3VnZ+MISIiApcuXUJhYaFrWlmG7uQWFBSE2267DTt37qy1Gsn7IiIiKhzVyMrK4rasuHHjxqFJkybYtWuXr0uhqygqKsL48eNdpxCV7Tj5rSZNmsBisZTbnp1OJ3Jycrg91wEnTpzAoEGDMGXKFLz00ktuvy44ONjn/zazAb9GVqsV/fr1w7fffuua9v3336OkpAQDBgwAAOzduxcbNmxwe34ynt69eyM4OLhcbt988w06derkGtVkzZo1OHToEACgoKCgwrnh+/fvR0xMjPeKphpXWlqKxYsXIzs7GwAwZMgQ7Nu3DxkZGa55vv32W46OUcelpaVh8eLFrnNDy/L+9fO5ubncng3uwoULGDlyJAICAvDNN98gODi43PO7d+/Gxo0bAVze0923b99yf8evX78eTqcT/fv392rdVD2HDx/G4MGDMW3aNMydO7fC86tWrcJPP/0EAMjPz0dJSUm55339bzNPQfHACy+8gBEjRqBevXqIiYnBq6++ipkzZyIyMhIA8OGHH2L//v1ITEx0a34ynnr16uHZZ5/F9OnTkZqaioKCArz22mv48ssvXfM88cQTrmEKMzMzkZSUhEmTJqFZs2bYsmULPv/8c6xevdqHn4Lc8e233+LixYs4d+4cDh8+jMWLFyMuLg69e/fGhQsXMGXKFNewdUOHDsWwYcMwduxY3H///di2bRt+/vlnnx3KJPfYbDasWLECuq4DuDzE6Llz59CvXz/ExsZix44dmDJlCiZNmgQ/Pz88++yzKCkpwcCBA3HhwgW8++67uOGGG3D99df79oNQlXRdR2JiIrKysnD//fe7LozWNA2TJ08GAPz73//G0aNHXcMCv/jiixg1ahSCgoIQHR2Nl19+GY8//jjv02FgycnJGDJkCBISEhAXF+c6VSwyMtK1ff7xj3/E7373O3Tu3Bnp6emYOnUqJk2ahKioKPzwww9YvHgxvvvuO599BjbgHhg8eDC2bduGjz76CPv378crr7yCqVOnup7v2bNnucH8rzY/GdPTTz+Ndu3auQ5jrl+/HgMHDnQ9P3r0aHTp0gUA0L59e6xcuRILFizAtm3b0LJlSxw5cqTCBXtkPOvWrUNWVha6desG4PKoRTfccAN69+6NgIAAJCUllfuxvHz5crz//vvYsWMHmjVrht27d5cb+52Mx2azucZ7T0pKwokTJ3DixAnExMQgNjYWzZs3R1JSEjTt8sHhf/7zn1iyZAk2btwIf39/vPjii5g8ebLreTIep9OJuLg4xMXFldurbbFYXA147969ER0d7Xpu6NCh2Lp1Kz755BMcOHAAr7/+OqZMmeL12sl9Fy9edO3cLNumASAhIcHVgI8dOxadO3cGcPnmaitWrMCCBQuwfft2xMXF4dixY2jZsqWXK///hPT1OCxERERERCbCn/FERERERF7EBpyIiIiIyIvYgBMREREReREbcCIiIiIiL2IDTkRERETkRWzAiYiIiIi8iA04EREREZEXsQEnIiKPbd26FdOnT3dr3ltuuQXHjx+v5YqIiIyLDTgRkULGjx+PrVu3ev19n3zySYwePdqteYcOHYrZs2fXckVERMbFO2ESEdVRY8eOxbPPPot+/fq5ph06dAgtWrRAw4YNvVbHf//7X4wfPx7p6emwWCxXnT8/Px/R0dH45ZdfEBMT44UKiYiMhXvAiYjqqAMHDqCgoKDctISEBK823wCwePFijB071q3mGwBCQ0PRv39/fPXVV7VcGRGRMbEBJyKqgx544AGcPXsWjzzyCHr16oUnnngCQMVTUEaNGoUvv/wSM2bMwJAhQ3D//ffj/PnzWLZsGcaOHYsRI0bgyy+/LLdsXdfxj3/8AzfddBNGjhyJefPmweFwVFnL1q1b0atXr3LTvv76a0yYMAFDhw7FM888g0uXLpV7vnfv3tiyZYunXwMRUZ3EBpyIqA764x//iEaNGuHhhx/Ge++957oA8uDBg8jPz3fNt3//fjz++OPo168f/vznP2PXrl0YMGAAPvroI/zxj3/E5MmTcfvtt+Pw4cOu19xzzz1YsGAB7r33Xjz++ONYtmwZHnzwwSprOX36NKKjo12PDx06hN/97ncYN24c/vKXv6BRo0Z4+umny70mOjoaZ86cqaFvg4iobvHzdQFERFR98fHxsFqtaNu2bYW9z7/17LPP4o477gAAzJw5E9OnT8fevXsRFBQEAPj444+xefNmdOzYEceOHcPChQuRlpaGyMhIAEDHjh0RGxuL1157DQ0aNKiw/JKSEvj7+7seZ2VloUmTJrjjjjvg7++PQYMGoaSkpNxrAgICKkwjIjILNuBERIqLi4tz/blhw4aIjo52Nd9l08rOJf/555+haRpuvPHGcsuQUuLkyZPo3r17heU3bdoU58+fdz1OTEzELbfcgm7duqFXr14YMmQIbrvttnKvOX/+PMLDw2vk8xER1TVswImI6ighRI0vs3HjxggICMB7771X4bl27dpV+poePXrg559/dj3WNA3z58+Hrus4fPgw5s+fj/fffx///e9/XfMcPHgQPXv2rPH6iYjqAp4DTkRURzVq1Ag5OTk1usw+ffogPDwcmzdvRs+ePdGrVy/Ex8djzZo1qFevXqWvGTt2LDZt2uR6vGHDBqxbtw6apqFz5864+eab8dNPP0HXdQCX96b/8MMPGDNmTI3WTkRUV7ABJyKqo+69917MmDED3bt3d42C4qng4GAsX74cixcvRkREBDp06IDWrVtX2XwDwKRJk3Ds2DEkJycDANq0aYM33ngDTZs2RadOnXD77bfj1VdfhaZd/ifnhx9+QHBwMIYOHVojNRMR1TW8EQ8RUR127tw5pKWloX79+oiLi6twI54DBw6gdevWqF+/PoDLN8FJS0tD586dXcs4ceIEQkJCXBddlsnJyUFeXh7i4uKuOsb3q6++ilOnTuHdd98tV1tOTg5atmxZ7pzzG2+8EVOnTsWUKVM8/vxERHURG3AiIvJYSUkJjh07hi5dulx13j179qBHjx61cg47EVFdwAaciIiIiMiLeA44EREREZEXsQEnIiIiIvIiNuBERERERF7EBpyIiIiIyIvYgBMREREReREbcCIiIiIiL2IDTkRERETkRWzAiYiIiIi8iA04EREREZEXsQEnIiIiIvKi/wdkQMHhWuzmCwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first return, bit-exact: y[24000] = 1.0\n", + "echo 2: peak at grid +0 samples, level 0.4541\n", + "echo 3: peak at grid +0 samples, level 0.2062\n", + "echo 4: peak at grid +1 samples, level 0.0983\n" + ] + } + ], + "source": [ + "m = machine(loop_seconds=0.5, regen=0.7, drive=0.0, darken_hz=8000)\n", + "x = np.zeros(int(2.5 * sr)); x[0] = 1.0\n", + "y = m.process(x)\n", + "\n", + "t = np.arange(y.size) / sr\n", + "fig, ax = plt.subplots()\n", + "ax.plot(t, y, color=C[0], lw=0.8)\n", + "for k in range(1, 5):\n", + " ax.axvline(k * 0.5, color=C[3], lw=0.8, ls=\":\")\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"output\")\n", + "ax.set_title(\"impulse → echoes on the 0.5 s grid (dotted)\")\n", + "plt.show()\n", + "\n", + "loop = int(0.5 * sr)\n", + "print(f\"first return, bit-exact: y[{loop}] = {y[loop]}\")\n", + "for k in range(2, 5):\n", + " w = np.abs(y[k * loop - 16 : k * loop + 16])\n", + " print(f\"echo {k}: peak at grid {int(np.argmax(w)) - 16:+d} samples, \"\n", + " f\"level {w.max():.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "bb0aabb1", + "metadata": {}, + "source": [ + "## 2 · Wear as the stabilizer\n", + "\n", + "Regen at exactly 1.0, drive 0.5, darken 3 kHz: a one-second noise burst, then twenty seconds\n", + "of free run. The windowed RMS settles and stays — no growth, no collapse. This is the regime\n", + "delay.h forbids (its feedback caps at 0.99) and this kernel exists for: the saturator bounds\n", + "the loop (|out| ≤ 1/drive), the DC blocker stops offset accumulation, and the darkening\n", + "lowpass decides *what* survives. (Pinned in the kernel test *\"regen 1.0 with drive engaged is\n", + "bounded and does not grow\"*.)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a49b1fbd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:22:18.426680Z", + "iopub.status.busy": "2026-08-12T01:22:18.426479Z", + "iopub.status.idle": "2026-08-12T01:22:18.734187Z", + "shell.execute_reply": "2026-08-12T01:22:18.732875Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RMS at 3 s: -20.02 dB at 19 s: -26.60 dB peak |y|: 1.074 (saturation bound 1/drive = 2.0)\n" + ] + } + ], + "source": [ + "rng = np.random.default_rng(2463534242)\n", + "m = machine(loop_seconds=0.25, regen=1.0, drive=0.5, darken_hz=3000)\n", + "x = np.zeros(int(20.0 * sr))\n", + "x[: int(1.0 * sr)] = 0.5 * rng.uniform(-1, 1, int(1.0 * sr))\n", + "y = m.process(x)\n", + "\n", + "win = int(0.5 * sr)\n", + "frames = y[: y.size // win * win].reshape(-1, win)\n", + "rms_db = 20 * np.log10(np.sqrt((frames ** 2).mean(axis=1)) + 1e-12)\n", + "tw = (np.arange(rms_db.size) + 0.5) * 0.5\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(tw, rms_db, color=C[0], marker=\"o\", ms=3)\n", + "ax.axvspan(0, 1, color=C[3], alpha=0.15, label=\"noise burst in\")\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"RMS (dB)\")\n", + "ax.set_title(\"regen 1.0: the loop sustains, bounded — it does not grow\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "print(f\"RMS at 3 s: {rms_db[6]:.2f} dB at 19 s: {rms_db[-2]:.2f} dB \"\n", + " f\"peak |y|: {np.abs(y).max():.3f} (saturation bound 1/drive = 2.0)\")" + ] + }, + { + "cell_type": "markdown", + "id": "2d439156", + "metadata": {}, + "source": [ + "## 3 · Per-pass darkening, against the analytic wear transfer\n", + "\n", + "A two-tone burst — 6 kHz above the 2 kHz darkening corner, 300 Hz below it — recirculated at\n", + "regen 0.9 with drive 0 (linear wear, so the per-pass ratio is exactly\n", + "`regen · |H_lowpass| · |H_dcblock|`). Measured level per pass, with the analytic prediction\n", + "drawn through it: the highs die generation by generation, the lows barely fade. The tape\n", + "forgets treble first." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0c417042", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:22:18.737298Z", + "iopub.status.busy": "2026-08-12T01:22:18.737011Z", + "iopub.status.idle": "2026-08-12T01:22:18.949787Z", + "shell.execute_reply": "2026-08-12T01:22:18.948553Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "per-pass ratio, 6 kHz: measured 0.292, predicted 0.292\n", + "per-pass ratio, 300 Hz: measured 0.890, predicted 0.890\n" + ] + } + ], + "source": [ + "m = machine(loop_seconds=0.25, regen=0.9, drive=0.0, darken_hz=2000)\n", + "f_hi, f_lo = 6000.0, 300.0\n", + "n_burst = int(0.1 * sr)\n", + "tt = np.arange(n_burst) / sr\n", + "x = np.zeros(int(1.6 * sr))\n", + "x[:n_burst] = 0.4 * np.sin(2 * np.pi * f_hi * tt) + 0.4 * np.sin(2 * np.pi * f_lo * tt)\n", + "y = m.process(x)\n", + "\n", + "def wear_gain(f, cutoff):\n", + " w = 2 * np.pi * f / sr\n", + " a = 1.0 - np.exp(-2 * np.pi * cutoff / sr)\n", + " ejw = np.exp(-1j * w)\n", + " lp = np.abs(a / (1 - (1 - a) * ejw))\n", + " r, nm = 0.999, (1 + 0.999) / 2\n", + " return lp * np.abs(nm * (1 - ejw) / (1 - r * ejw))\n", + "\n", + "loop = int(0.25 * sr)\n", + "passes = np.arange(1, 6)\n", + "hi = [goertzel(y[k * loop : k * loop + n_burst], f_hi) for k in passes]\n", + "lo = [goertzel(y[k * loop : k * loop + n_burst], f_lo) for k in passes]\n", + "pred_hi = hi[0] * (0.9 * wear_gain(f_hi, 2000.0)) ** (passes - 1)\n", + "pred_lo = lo[0] * (0.9 * wear_gain(f_lo, 2000.0)) ** (passes - 1)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.semilogy(passes, hi, \"o\", color=C[0], label=\"6 kHz measured\")\n", + "ax.semilogy(passes, pred_hi, \"-\", color=C[0], lw=1, alpha=0.6, label=\"6 kHz predicted\")\n", + "ax.semilogy(passes, lo, \"s\", color=C[1], label=\"300 Hz measured\")\n", + "ax.semilogy(passes, pred_lo, \"-\", color=C[1], lw=1, alpha=0.6, label=\"300 Hz predicted\")\n", + "ax.set_xticks(passes)\n", + "ax.set_xlabel(\"pass through the loop\"); ax.set_ylabel(\"tone level\")\n", + "ax.set_title(\"generation loss: measured vs. regen · |H_wear| per pass\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "print(f\"per-pass ratio, 6 kHz: measured {hi[1]/hi[0]:.3f}, \"\n", + " f\"predicted {0.9 * wear_gain(f_hi, 2000.0):.3f}\")\n", + "print(f\"per-pass ratio, 300 Hz: measured {lo[1]/lo[0]:.3f}, \"\n", + " f\"predicted {0.9 * wear_gain(f_lo, 2000.0):.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ba6ec3e4", + "metadata": {}, + "source": [ + "## 4 · The transport, in cents\n", + "\n", + "Wow at 2 ms / 0.5 Hz on a 440 Hz sine, pitch-tracked with the same DspTap YIN detector the\n", + "tune kernel uses. The peak deviation of a sinusoidally modulated read is\n", + "`depth · 2π · rate` in pitch ratio — 2 ms at 0.5 Hz predicts ±10.9 cents — and the track\n", + "should breathe at exactly the wow rate. The transport is periodic and deterministic by\n", + "design: two renders are bit-identical (pinned in *\"wow bends pitch by the set depth, and two\n", + "runs are bit-exact\"*)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4322f097", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:22:18.952920Z", + "iopub.status.busy": "2026-08-12T01:22:18.952677Z", + "iopub.status.idle": "2026-08-12T01:22:19.522257Z", + "shell.execute_reply": "2026-08-12T01:22:19.521071Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "measured peak deviation: 10.9 cents (predicted 10.9)\n" + ] + } + ], + "source": [ + "m = machine(loop_seconds=1.0, regen=0.0, wow=(2.0, 0.5))\n", + "tt = np.arange(int(6.0 * sr)) / sr\n", + "y = m.process(0.8 * np.sin(2 * np.pi * 440.0 * tt))\n", + "\n", + "hop = 1024\n", + "periods = tap.Yin().track(y[int(1.5 * sr):], hop=hop)\n", + "voiced = periods > 0\n", + "cents = np.full(periods.size, np.nan)\n", + "cents[voiced] = 1200 * np.log2((sr / periods[voiced]) / 440.0)\n", + "tt_track = np.arange(periods.size) * hop / sr\n", + "\n", + "predicted = 1200 / np.log(2) * 0.002 * 2 * np.pi * 0.5\n", + "fig, ax = plt.subplots()\n", + "ax.plot(tt_track, cents, color=C[0], lw=1)\n", + "ax.axhline(+predicted, color=C[3], lw=0.8, ls=\":\", label=f\"predicted ±{predicted:.1f} c\")\n", + "ax.axhline(-predicted, color=C[3], lw=0.8, ls=\":\")\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"deviation (cents)\")\n", + "ax.set_title(\"wow 2 ms @ 0.5 Hz on a 440 Hz sine: the playback breathes\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "print(f\"measured peak deviation: {np.nanmax(np.abs(cents)):.1f} cents \"\n", + " f\"(predicted {predicted:.1f})\")" + ] + }, + { + "cell_type": "markdown", + "id": "6b11cace", + "metadata": {}, + "source": [ + "## 5 · The performance move\n", + "\n", + "The rig's fader was the *input send*, not the loop: play into the machine, then fade the\n", + "send to zero and the piece keeps unrolling on the tape alone. Four slow notes into a 2 s\n", + "loop at regen 1.0; the send fades out at t = 10 s; the loop carries the material on,\n", + "bounded, worn a shade darker every pass. This is the whole record in one gesture." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d1a7aa31", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:22:19.524914Z", + "iopub.status.busy": "2026-08-12T01:22:19.524675Z", + "iopub.status.idle": "2026-08-12T01:22:20.097566Z", + "shell.execute_reply": "2026-08-12T01:22:20.095601Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Audio\n", + "\n", + "m = machine(loop_seconds=2.0, regen=1.0, drive=0.6, darken_hz=2500, mix=100,\n", + " smooth_ms=50)\n", + "dur = 30.0\n", + "x = np.zeros(int(dur * sr))\n", + "for i, midi in enumerate([57, 64, 62, 69]): # A3 E4 D4 A4\n", + " f = 440.0 * 2 ** ((midi - 69) / 12)\n", + " n0 = int((1.0 + 2.2 * i) * sr)\n", + " seg = np.arange(int(1.8 * sr))\n", + " env = np.minimum(1, seg / (0.3 * sr)) * np.exp(-seg / (0.9 * sr))\n", + " x[n0 : n0 + seg.size] += 0.35 * env * np.sin(2 * np.pi * f * seg / sr)\n", + "\n", + "y = np.empty_like(x)\n", + "n_fade = int(10.0 * sr)\n", + "y[:n_fade] = m.process(x[:n_fade])\n", + "m.set(input_level=0.0) # the fade: smooth_ms=50 glides the send down\n", + "y[n_fade:] = m.process(x[n_fade:])\n", + "\n", + "win = int(0.5 * sr)\n", + "frames = y[: y.size // win * win].reshape(-1, win)\n", + "rms = np.sqrt((frames ** 2).mean(axis=1))\n", + "fig, ax = plt.subplots()\n", + "ax.plot((np.arange(rms.size) + 0.5) * 0.5, 20 * np.log10(rms + 1e-12), color=C[0])\n", + "ax.axvline(10.0, color=C[3], ls=\":\", label=\"send faded to 0\")\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"RMS (dB)\")\n", + "ax.set_title(\"fade the send at 10 s: the loop keeps playing the piece\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "Audio(np.clip(y, -1, 1), rate=int(sr))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/taptools_py.py b/notebooks/taptools_py.py index 15b07fd..be4971b 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -14,7 +14,8 @@ (`Diode`), tap.303~ (`TB303`), tap.vco~ (`Vco`), tap.autowah~ (`Wah`), tap.overdrive~ (`Overdrive`), the step-sequencer rows behind tap.808.seq~ / tap.303.seq~ (`TriggerRow`, `NoteRow`), tap.808.kick~ (`Kick`), -tap.delay~ (`Delay`), tap.multitap~ (`Multitap`), and tap.tune~'s pitch +tap.delay~ (`Delay`), tap.multitap~ (`Multitap`), the Discreet Music +two-machine tape loop tap.discreet~ (`Discreet`), and tap.tune~'s pitch corrector (`Tune`, with the shared DspTap detector passed through as `Yin` for the notebooks' pitch tracking). Parameter names on the kernel classes mirror each kernel header's param_index enum. @@ -262,6 +263,20 @@ def load() -> ctypes.CDLL: "taptools_multitap_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), "taptools_multitap_clear": ([vp], ctypes.c_int), "taptools_multitap_process": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_discreet_create": ([], vp), + "taptools_discreet_destroy": ([vp], None), + "taptools_discreet_prepare": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_discreet_set_loop_seconds": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_discreet_set_regen": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_discreet_set_darken_hz": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_discreet_set_drive": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_discreet_set_input_level": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_discreet_set_mix": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_discreet_set_wow": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_discreet_set_flutter": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_discreet_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_discreet_clear": ([vp], ctypes.c_int), + "taptools_discreet_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), "taptools_yin_create": ([ctypes.c_int, ctypes.c_int, ctypes.c_int], vp), "taptools_yin_destroy": ([vp], None), "taptools_yin_frame_size": ([vp], ctypes.c_int), @@ -1064,6 +1079,65 @@ def __del__(self): self._h = None +class Discreet: + """tap.discreet~'s kernel (tap::tools::discreet::machine): the Discreet + Music two-tape-machine regeneration loop. Regen legally reaches 1.0 — + stability comes from the wear path (darkening lowpass, bounded soft + saturation, DC blocker), not a feedback cap. Loop-time changes glide as + tape-speed doppler; wow/flutter are a deterministic periodic transport.""" + + def __init__(self, sr: float = 48000.0, max_loop_seconds: float = 30.0, **params): + self._h = _LIB.taptools_discreet_create() + _check(_LIB.taptools_discreet_prepare(self._h, float(sr), float(max_loop_seconds)), + "prepare") + self.set(**params) + + def set(self, *, loop_seconds=None, regen=None, darken_hz=None, drive=None, + input_level=None, mix=None, wow=None, flutter=None, smooth_ms=None) -> "Discreet": + """`wow` and `flutter` take (depth_ms, rate_hz) pairs.""" + # configuration first, so ramped targets in the same call honor the new slew + if smooth_ms is not None: + _check(_LIB.taptools_discreet_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + if wow is not None: + depth, rate = wow + _check(_LIB.taptools_discreet_set_wow(self._h, float(depth), float(rate)), "wow") + if flutter is not None: + depth, rate = flutter + _check(_LIB.taptools_discreet_set_flutter(self._h, float(depth), float(rate)), + "flutter") + if loop_seconds is not None: + _check(_LIB.taptools_discreet_set_loop_seconds(self._h, float(loop_seconds)), + "loop_seconds") + if regen is not None: + _check(_LIB.taptools_discreet_set_regen(self._h, float(regen)), "regen") + if darken_hz is not None: + _check(_LIB.taptools_discreet_set_darken_hz(self._h, float(darken_hz)), "darken_hz") + if drive is not None: + _check(_LIB.taptools_discreet_set_drive(self._h, float(drive)), "drive") + if input_level is not None: + _check(_LIB.taptools_discreet_set_input_level(self._h, float(input_level)), + "input_level") + if mix is not None: + _check(_LIB.taptools_discreet_set_mix(self._h, float(mix)), "mix") + return self + + def process(self, x) -> np.ndarray: + x = _f64(x) + out = np.zeros_like(x) + _check(_LIB.taptools_discreet_process(self._h, _p64(x), _p64(out), x.size), "process") + return out + + def clear(self) -> None: + """The eject button: erases the tape, keeps the parameters.""" + _check(_LIB.taptools_discreet_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_discreet_destroy(h) + self._h = None + + class Yin: """The shared DspTap pitch detector (tap::dsp::yin), passed through the C ABI so the notebooks can track pitch with the same detector the corrector uses.""" diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index 29d3a62..51b93cd 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -1071,4 +1072,70 @@ int taptools_od_process(taptools_od h, const double* in, double* out, int n) { return with(h, [&](overdrive& o) { o.process(in, out, static_cast(n)); }); } +// ---- tap.discreet~ ------------------------------------------------------------------------------- + +using discreet_machine = tap::tools::discreet::machine; + +taptools_discreet taptools_discreet_create(void) { + return static_cast(new discreet_machine()); +} + +void taptools_discreet_destroy(taptools_discreet h) { + delete static_cast(h); +} + +int taptools_discreet_prepare(taptools_discreet h, double sr, double max_loop_seconds) { + if (max_loop_seconds <= 0.0) { + return -1; + } + return with(h, [&](discreet_machine& m) { m.prepare(sr, max_loop_seconds); }); +} + +int taptools_discreet_set_loop_seconds(taptools_discreet h, double s) { + return with(h, [&](discreet_machine& m) { m.set_loop_seconds(s); }); +} + +int taptools_discreet_set_regen(taptools_discreet h, double r) { + return with(h, [&](discreet_machine& m) { m.set_regen(r); }); +} + +int taptools_discreet_set_darken_hz(taptools_discreet h, double hz) { + return with(h, [&](discreet_machine& m) { m.set_darken_hz(hz); }); +} + +int taptools_discreet_set_drive(taptools_discreet h, double d) { + return with(h, [&](discreet_machine& m) { m.set_drive(d); }); +} + +int taptools_discreet_set_input_level(taptools_discreet h, double lin) { + return with(h, [&](discreet_machine& m) { m.set_input_level(lin); }); +} + +int taptools_discreet_set_mix(taptools_discreet h, double pct) { + return with(h, [&](discreet_machine& m) { m.set_mix(pct); }); +} + +int taptools_discreet_set_wow(taptools_discreet h, double depth_ms, double rate_hz) { + return with(h, [&](discreet_machine& m) { m.set_wow(depth_ms, rate_hz); }); +} + +int taptools_discreet_set_flutter(taptools_discreet h, double depth_ms, double rate_hz) { + return with(h, [&](discreet_machine& m) { m.set_flutter(depth_ms, rate_hz); }); +} + +int taptools_discreet_set_smooth_ms(taptools_discreet h, double ms) { + return with(h, [&](discreet_machine& m) { m.set_smooth_ms(ms); }); +} + +int taptools_discreet_clear(taptools_discreet h) { + return with(h, [&](discreet_machine& m) { m.clear(); }); +} + +int taptools_discreet_process(taptools_discreet h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](discreet_machine& m) { m.process(in, out, static_cast(n)); }); +} + } // extern "C" diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index 40c147a..5e47b34 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -346,6 +346,26 @@ TAPTOOLS_API int taptools_od_set_smooth_ms(taptools_od h, double ms); TAPTOOLS_API int taptools_od_clear(taptools_od h); TAPTOOLS_API int taptools_od_process(taptools_od h, const double* in, double* out, int n); +// ---- tap.discreet~ (tap::tools::discreet::machine) ----------------------------------------------- + +typedef void* taptools_discreet; + +TAPTOOLS_API taptools_discreet taptools_discreet_create(void); +TAPTOOLS_API void taptools_discreet_destroy(taptools_discreet h); +/// Buy tape for `max_loop_seconds` at `sr`; snaps ramps and erases the tape. +TAPTOOLS_API int taptools_discreet_prepare(taptools_discreet h, double sr, double max_loop_seconds); +TAPTOOLS_API int taptools_discreet_set_loop_seconds(taptools_discreet h, double s); // slewed: tape-speed doppler +TAPTOOLS_API int taptools_discreet_set_regen(taptools_discreet h, double r); // 0..1; 1.0 legally sustains +TAPTOOLS_API int taptools_discreet_set_darken_hz(taptools_discreet h, double hz); // per-pass wear corner +TAPTOOLS_API int taptools_discreet_set_drive(taptools_discreet h, double d); // >= 0; 0 exactly linear +TAPTOOLS_API int taptools_discreet_set_input_level(taptools_discreet h, double lin); // the send fader +TAPTOOLS_API int taptools_discreet_set_mix(taptools_discreet h, double pct); // 0..100, equal-power +TAPTOOLS_API int taptools_discreet_set_wow(taptools_discreet h, double depth_ms, double rate_hz); +TAPTOOLS_API int taptools_discreet_set_flutter(taptools_discreet h, double depth_ms, double rate_hz); +TAPTOOLS_API int taptools_discreet_set_smooth_ms(taptools_discreet h, double ms); +TAPTOOLS_API int taptools_discreet_clear(taptools_discreet h); +TAPTOOLS_API int taptools_discreet_process(taptools_discreet h, const double* in, double* out, int n); + #ifdef __cplusplus } #endif From ecae1614059891d1e72e97e439a46e90d5c19cfe Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 12 Aug 2026 01:26:20 +0000 Subject: [PATCH 3/9] Add the Music for Airports incommensurate loop bank MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit airport.h (tap.airport~) recreates the "2/1" tape system from Eno's published accounts: up to eight free-running loops of unequal lengths, each a tape_loop.h reel with a single head that both plays and records. The phase is never reset by any setter — the free-run is the piece — and a length change is an honest splice that re-wraps without rewinding. Per-loop level, equal-power pan (exact endpoints, the delay.h multitap law), and a playback darken corner that bypasses to bit-transparency at the band ceiling; no per-pass generation loss, because a loop replays the same magnetic imprint. composite_period_seconds() reports the lcm of the active lengths, +inf on overflow. Tests pin the structural promises exactly: bit-exact returns on the loop grid through a mid-run setter storm, bit-exact freeze at record-off, the lcm realignment of coprime lengths (and non-realignment at half), hard pans bitwise absent from the far bus, the darken shade measured against the analytic one-pole transfer, and the splice law. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_016zgrm1MGS1eir4hCfZBJaR --- README.md | 1 + include/taptools/airport.h | 298 ++++++++++++++++++++++++++++++++++++ include/taptools/taptools.h | 1 + tests/CMakeLists.txt | 1 + tests/airport_test.cpp | 241 +++++++++++++++++++++++++++++ 5 files changed, 542 insertions(+) create mode 100644 include/taptools/airport.h create mode 100644 tests/airport_test.cpp diff --git a/README.md b/README.md index c658c73..cf92a72 100644 --- a/README.md +++ b/README.md @@ -77,6 +77,7 @@ header adds no nested namespace, the class) the kernel lives in. |---|---|---| | `tape_loop.h` | *(shared)* | Tape reel, wow/flutter transport, generation-loss wear (`tap::tools::tape`) | | `discreet.h` | `tap.discreet~` | *Discreet Music* two-machine regeneration loop (`tap::tools::discreet`) | +| `airport.h` | `tap.airport~` | *Music for Airports* incommensurate loop bank (`tap::tools::airport`) | `taptools.h` is the umbrella header that pulls in every kernel above. `stft.h`, `tune.h`, `harmonizer.h` and `conv_engine.h` reach into `tap::dsp` (the pinned DspTap submodule) for the diff --git a/include/taptools/airport.h b/include/taptools/airport.h new file mode 100644 index 0000000..cb8dc39 --- /dev/null +++ b/include/taptools/airport.h @@ -0,0 +1,298 @@ +/// @file +/// @brief Portable incommensurate-loop-bank kernel for tap.airport~ — no Max/Min dependency. +/// @details A recreation of the tape system behind "2/1" on Brian Eno's *Music for Airports* +/// (Ambient 1, EG, 1978), as described in Eno's own published accounts (the album's +/// liner notes and *A Year with Swollen Appendices*, Faber, 1996): a small number of +/// long tape loops — around seven, each holding one recorded phrase — of unequal, +/// incommensurate lengths, all free-running, so the phrases drift in and out of +/// coincidence and the piece never repeats on a human timescale. The composition IS +/// the phase system; the machine just keeps the loops turning. +/// +/// Each of up to k_max_loops loops is a tape_loop.h reel with a single free-running +/// head that both plays and records. `record(loop, true)` punches the input onto that +/// loop's tape at wherever its head happens to be — the phase is NEVER reset, by +/// record or by any setter, because the free-run is the piece — and `record(loop, +/// false)` freezes the tape bit-exactly. Playback is read-before-write, so while +/// recording you hear the previous generation under the head. Per-loop level and +/// equal-power pan (exact endpoints, the delay.h multitap law) place each phrase in +/// the stereo field; a per-loop `darken` corner shades its playback tone (a +/// tape_loop.h wear stage with drive fixed at 0 — a real loop replays the *same* +/// magnetic imprint every pass, so there is no per-pass generation loss to model, and +/// pretending otherwise would be dishonest; at the band ceiling the stage is bypassed +/// entirely and playback is bit-transparent). +/// +/// Geometry: prepare(sr, max_loop_seconds) buys k_max_loops worst-case reels — the +/// family's largest buy (8 loops x 30 s at 48 kHz is ~92 MB of double tape); size +/// max_loop_seconds to the piece. No later call allocates. +/// +/// Honest limits: +/// - A length change is a splice: the tape keeps its content and the head re-wraps +/// modulo the new length. It can land mid-phrase and click — that is what splicing +/// tape does. It never rewinds. +/// - Recording starts at the head's current position, not at a downbeat. There is no +/// quantized punch-in; Eno's rig had none. +/// - The Hermite playback read spans two samples ahead of the record head, so for ~2 +/// samples around the punch point one generation blends into the next. +/// - No wow/flutter here: the phasing engine of "2/1" is the incommensurate lengths, +/// not pitch drift. Run a loop's source through tap.discreet~ first if you want +/// tape breath. +/// - composite_period_seconds() is informational (long-long lcm of the active loop +/// lengths in samples; +inf when it overflows — with incommensurate lengths it is +/// astronomically long, which is the point). +/// - No dry path and no master gain: gain staging is the caller's job. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include +#include + +#include "tape_loop.h" // tap::tools::tape — reel / wear / ramp, the shared machinery + +namespace tap::tools { + namespace airport { + + constexpr int k_max_loops = 8; // "2/1" used about seven; eight buys a spare + constexpr double k_min_loop_seconds = 0.5; // shorter is a delay effect, not a phrase loop + constexpr double k_default_max_seconds = 30.0; // worst case per loop (~92 MB total @ 48k) + constexpr double k_default_smooth_ms = 20.0; // anti-zipper ramp for level/pan/darken + + /// Up to eight free-running tape loops of unequal lengths, summed to stereo. + class loop_bank { + public: + loop_bank() { + for (auto& l : m_loops) { + l.level.snap(1.0); + l.darken_hz.snap(tape::k_darken_ceil_hz); // transparent until asked to shade + } + } + + // -- lifecycle ----------------------------------------------------------------------- + + /// Buy k_max_loops reels for `max_loop_seconds` at `sr`, apply the stored lengths, + /// snap all ramps, erase all tape, and rewind every head — a DSP restart is the one + /// thing allowed to touch the phases. Not real-time-safe. + void prepare(double sr, double max_loop_seconds = k_default_max_seconds) { + m_sr = (sr > 0.0) ? sr : 48000.0; + for (auto& l : m_loops) { + l.tape.prepare(m_sr, std::max(k_min_loop_seconds, max_loop_seconds)); + l.tape.set_loop_samples(seconds_to_samples(l.length_seconds)); + l.length_seconds = static_cast(l.tape.loop_samples()) / m_sr; + l.shade.prepare(m_sr); + l.level.snap(l.level.target()); + l.pan.snap(l.pan.target()); + l.darken_hz.snap(l.darken_hz.target()); + l.shade.set_cutoff_hz(l.darken_hz.current()); + } + clear(); + } + + /// Erase every tape and rewind every head; parameters (lengths, levels, pans, darken, + /// record gates) are untouched. + void clear() { + for (auto& l : m_loops) { + l.tape.clear(); + l.shade.clear(); + l.phase = 0.0; + } + } + + bool prepared() const { return m_loops[0].tape.prepared(); } + + // -- structure (instant; never touches a phase) -------------------------------------- + + /// Number of active loops, clamped to [0, k_max_loops]. Newly activated loops come in + /// at their stored settings, their heads wherever they last were. + void set_loops(int count) { m_num_loops = std::clamp(count, 0, k_max_loops); } + + /// Per-loop length in seconds, clamped to [k_min_loop_seconds, the prepared max]. + /// A splice: content kept, head re-wraps modulo the new length, never rewinds. + void set_length_seconds(int loop, double s) { + if (!valid_loop(loop)) { + return; + } + loop_state& l = m_loops[static_cast(loop)]; + l.length_seconds = std::max(k_min_loop_seconds, s); + if (l.tape.prepared()) { + l.tape.set_loop_samples(seconds_to_samples(l.length_seconds)); + l.length_seconds = static_cast(l.tape.loop_samples()) / m_sr; + const double n = static_cast(l.tape.loop_samples()); + l.phase = l.phase - std::floor(l.phase / n) * n; // re-wrap, no rewind + } + } + + /// Punch the input onto this loop's tape (true) or freeze it bit-exactly (false). + /// Recording replaces — no overdub sum; Eno recorded each phrase once. + void record(int loop, bool on) { + if (valid_loop(loop)) { + m_loops[static_cast(loop)].recording = on; + } + } + + // -- parameter targets (click-free; safe while audio runs) --------------------------- + + /// Per-loop linear playback level, slewed. Unclamped (negative flips polarity). + void set_level(int loop, double lin) { + if (valid_loop(loop)) { + m_loops[static_cast(loop)].level.to(lin, smooth_samples()); + } + } + + /// Per-loop equal-power pan, -1 (hard left) .. 1 (hard right), slewed. Endpoints are + /// exact: a hard-panned loop is bitwise absent from the far bus (delay.h law). + void set_pan(int loop, double pan) { + if (valid_loop(loop)) { + m_loops[static_cast(loop)].pan.to(std::clamp(pan, -1.0, 1.0), smooth_samples()); + } + } + + /// Per-loop playback darkening corner in Hz, slewed. At the band ceiling (the + /// default) the stage is bypassed and playback is bit-transparent. + void set_darken_hz(int loop, double hz) { + if (valid_loop(loop)) { + m_loops[static_cast(loop)].darken_hz.to( + std::clamp(hz, tape::k_darken_floor_hz, tape::k_darken_ceil_hz), smooth_samples()); + } + } + + void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + + // -- introspection ------------------------------------------------------------------- + + int loops() const { return m_num_loops; } + double length_seconds(int loop) const { + return valid_loop(loop) ? m_loops[static_cast(loop)].length_seconds : 0.0; + } + bool recording(int loop) const { return valid_loop(loop) && m_loops[static_cast(loop)].recording; } + double level(int loop) const { + return valid_loop(loop) ? m_loops[static_cast(loop)].level.target() : 0.0; + } + double pan(int loop) const { + return valid_loop(loop) ? m_loops[static_cast(loop)].pan.target() : 0.0; + } + double darken_hz(int loop) const { + return valid_loop(loop) ? m_loops[static_cast(loop)].darken_hz.target() : 0.0; + } + double smooth_ms() const { return m_smooth_ms; } + double samplerate() const { return m_sr; } + double max_loop_seconds() const { + return prepared() ? static_cast(m_loops[0].tape.capacity()) / m_sr : 0.0; + } + + /// This loop's head position as a fraction of its length, 0..1 — read-only, so tests + /// can pin the promise that nothing but prepare()/clear() ever resets it. + double phase(int loop) const { + if (!valid_loop(loop) || !prepared()) { + return 0.0; + } + const loop_state& l = m_loops[static_cast(loop)]; + return l.phase / static_cast(l.tape.loop_samples()); + } + + /// Least common multiple of the active loop lengths, in seconds — how long until the + /// whole system realigns. Informational; +inf on 64-bit overflow (incommensurate + /// lengths overflow fast, which is the point of the piece). + double composite_period_seconds() const { + if (!prepared() || m_num_loops < 1) { + return 0.0; + } + long long acc = 1; + for (int i = 0; i < m_num_loops; ++i) { + const long long n = static_cast(m_loops[static_cast(i)].tape.loop_samples()); + const long long g = gcd_ll(acc, n); + if (acc / g > std::numeric_limits::max() / n) { + return std::numeric_limits::infinity(); + } + acc = acc / g * n; + } + return static_cast(acc) / m_sr; + } + + // -- audio --------------------------------------------------------------------------- + + /// Sum the active loops to the stereo bus; punch `in` onto any recording loop. + void process(double in, double& out_left, double& out_right) { + out_left = 0.0; + out_right = 0.0; + if (!prepared()) { + return; + } + for (int i = 0; i < m_num_loops; ++i) { + loop_state& l = m_loops[static_cast(i)]; + const double played = l.tape.read_hermite(l.phase); + const double shade_hz = l.darken_hz.tick(); + double toned = played; + if (shade_hz < tape::k_darken_ceil_hz) { // ceiling = bypass, bit-transparent + if (shade_hz != l.shade.cutoff_hz()) { + l.shade.set_cutoff_hz(shade_hz); + } + toned = l.shade.process(played); + } + const double g = l.level.tick() * toned; + const double pan = l.pan.tick(); + // Equal-power with exact endpoints — same law as delay.h multitap. + if (pan <= -1.0) { + out_left += g; + } + else if (pan >= 1.0) { + out_right += g; + } + else { + const double theta = (pan + 1.0) * 0.25 * tape::k_pi; + out_left += std::cos(theta) * g; + out_right += std::sin(theta) * g; + } + if (l.recording) { // read-before-write: you hear the old pass under the head + l.tape.write(static_cast(std::floor(l.phase)), in); + } + l.phase += 1.0; + if (l.phase >= static_cast(l.tape.loop_samples())) { + l.phase -= static_cast(l.tape.loop_samples()); + } + } + } + + /// Block form: the trivial loop over the scalar path. + void process(const double* in, double* out_left, double* out_right, size_t n) { + for (size_t i = 0; i < n; ++i) { + process(in[i], out_left[i], out_right[i]); + } + } + + private: + struct loop_state { + tape::reel tape; + tape::wear shade; // playback tone only: drive stays 0, bypassed at ceiling + double phase{0.0}; // samples into the loop; the piece lives here + double length_seconds{k_min_loop_seconds}; + bool recording{false}; + tape::ramp level; // linear + tape::ramp pan; // -1..1 + tape::ramp darken_hz; // Hz + }; + + static long long gcd_ll(long long a, long long b) { + while (b != 0) { + const long long t = a % b; + a = b; + b = t; + } + return a; + } + + bool valid_loop(int loop) const { return loop >= 0 && loop < k_max_loops; } + long smooth_samples() const { return static_cast(m_smooth_ms * 0.001 * m_sr); } + long seconds_to_samples(double s) const { return static_cast(std::ceil(s * m_sr)); } + + double m_sr{48000.0}; + double m_smooth_ms{k_default_smooth_ms}; + int m_num_loops{0}; + std::array m_loops; + }; + + } // namespace airport +} // namespace tap::tools diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index 03c93bf..5f3643f 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -7,6 +7,7 @@ #pragma once +#include "airport.h" #include "autowah.h" #include "bridged_t.h" #include "conv_engine.h" diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index b38c71d..bc7300e 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -13,6 +13,7 @@ FetchContent_MakeAvailable(Catch2) add_executable(taptools_kernel_tests adsr_test.cpp + airport_test.cpp autowah_test.cpp delay_test.cpp diode_ladder_test.cpp diff --git a/tests/airport_test.cpp b/tests/airport_test.cpp new file mode 100644 index 0000000..f84e803 --- /dev/null +++ b/tests/airport_test.cpp @@ -0,0 +1,241 @@ +/// @file +/// @brief Catch2 scenarios pinning the tap.airport~ kernel (airport.h). +/// @details The promises are structural, so the measurements are exact: recorded phrases must +/// return on their loop's grid bit-for-bit, no setter may touch a phase (the free-run +/// IS the piece), hard pans must be bitwise absent from the far bus, and the +/// composite period of coprime loop lengths must be their lcm to the sample. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include + +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + + using tap::tools::airport::loop_bank; + + loop_bank make(double max_loop_seconds = 2.0) { + loop_bank b; + b.prepare(k_sr, max_loop_seconds); + b.set_smooth_ms(0.0); + return b; + } + + size_t at(double seconds) { + return static_cast(seconds * k_sr); + } + + /// Punch a single unit impulse onto `loop` at its current head position. + void plant_click(loop_bank& b, int loop) { + double l = 0.0, r = 0.0; + b.record(loop, true); + b.process(1.0, l, r); + b.record(loop, false); + } + + double goertzel(const std::vector& x, double f, size_t begin, size_t end) { + const double w = 2.0 * 3.14159265358979323846 * f / k_sr; + const double coef = 2.0 * std::cos(w); + double s1 = 0.0, s2 = 0.0; + for (size_t i = begin; i < end; ++i) { + const double s = x[i] + coef * s1 - s2; + s2 = s1; + s1 = s; + } + const double n = static_cast(end - begin); + const double re = s1 - s2 * std::cos(w); + const double im = s2 * std::sin(w); + return 2.0 * std::sqrt(re * re + im * im) / n; + } + +} // namespace + +SCENARIO("a recorded phrase returns every loop period and no setter resets the phase") { + loop_bank b = make(); + b.set_loops(1); + b.set_length_seconds(0, 0.5); + b.set_pan(0, -1.0); // hard left: the left bus carries the loop bitwise + + plant_click(b, 0); + + const size_t loop = at(0.5); + std::vector yl(4 * loop, 0.0); + double r = 0.0; + for (size_t i = 0; i < yl.size(); ++i) { + if (i == loop + 100) { // mid-run setter storm: none of these may touch the head + b.set_level(0, 1.0); + b.set_darken_hz(0, tap::tools::tape::k_darken_ceil_hz); + b.record(0, false); + b.set_length_seconds(0, 0.5); + b.set_loops(1); + } + b.process(0.0, yl[i], r); + } + + // The click was planted one sample into the run, so it returns at loop - 1, 2*loop - 1, ... + for (size_t k = 1; k <= 3; ++k) { + INFO("return " << k); + CHECK(yl[k * loop - 1] == 1.0); // bitwise: transparent playback of the same imprint + } + + // And the head advances by exactly the samples processed, storm or no storm. + const double ph = b.phase(0); + INFO("phase after 4 loops + 1 planted sample: " << ph); + CHECK(std::abs(ph - 1.0 / static_cast(loop)) < 1e-9); +} + +SCENARIO("record off freezes the tape bit-exactly") { + loop_bank b = make(); + b.set_loops(1); + b.set_length_seconds(0, 0.5); + b.set_pan(0, -1.0); + + const size_t loop = at(0.5); + double l = 0.0, r = 0.0; + b.record(0, true); + for (size_t i = 0; i < loop; ++i) { // one full pass of a phrase, then freeze + const double t = static_cast(i) / k_sr; + b.process(0.7 * std::sin(2.0 * 3.14159265358979323846 * 440.0 * t), l, r); + } + b.record(0, false); + + std::vector pass_a(loop, 0.0), pass_b(loop, 0.0); + for (size_t i = 0; i < loop; ++i) { + b.process(0.0, pass_a[i], r); + } + for (size_t i = 0; i < loop; ++i) { + b.process(0.0, pass_b[i], r); + } + bool exact = true; + for (size_t i = 0; i < loop; ++i) { + exact = exact && (pass_a[i] == pass_b[i]); // bitwise, not approximately + } + REQUIRE(exact); + REQUIRE(*std::max_element(pass_a.begin(), pass_a.end()) > 0.5); // and it is the phrase, not silence +} + +SCENARIO("two incommensurate loops realign only at the lcm") { + loop_bank b = make(); + b.set_loops(2); + b.set_length_seconds(0, 0.5); // 24000 samples + b.set_length_seconds(1, 0.625); // 30000 samples; gcd 6000 -> lcm 120000 samples = 2.5 s + b.set_pan(0, -1.0); + b.set_pan(1, -1.0); // both on the left bus: the sum is where coincidence lives + + REQUIRE(b.composite_period_seconds() == 2.5); + + plant_click(b, 0); + plant_click(b, 1); + + const size_t period = at(2.5); + std::vector yl(2 * period, 0.0); + double r = 0.0; + for (size_t i = 0; i < yl.size(); ++i) { + b.process(0.0, yl[i], r); + } + + bool repeats_at_lcm = true; + for (size_t i = 0; i < period; ++i) { + repeats_at_lcm = repeats_at_lcm && (yl[i] == yl[i + period]); + } + REQUIRE(repeats_at_lcm); + + bool differs_at_half = false; + for (size_t i = 0; i < period / 2; ++i) { + differs_at_half = differs_at_half || (yl[i] != yl[i + period / 2]); + } + REQUIRE(differs_at_half); // half the lcm is not a period: the pattern is still drifting +} + +SCENARIO("a hard-panned loop is bitwise absent from the far bus") { + loop_bank b = make(); + b.set_loops(1); + b.set_length_seconds(0, 0.5); + b.set_pan(0, -1.0); + + plant_click(b, 0); + + double l = 0.0, r = 0.0; + bool right_silent = true; + double left_peak = 0.0; + for (size_t i = 0; i < at(1.5); ++i) { + b.process(0.0, l, r); + right_silent = right_silent && (r == 0.0); + left_peak = std::max(left_peak, std::abs(l)); + } + REQUIRE(right_silent); + REQUIRE(left_peak == 1.0); +} + +SCENARIO("darken shades one loop's playback and only that loop's") { + loop_bank b = make(); + b.set_loops(2); + b.set_length_seconds(0, 0.5); + b.set_length_seconds(1, 0.5); + b.set_pan(0, -1.0); // shaded loop on the left bus + b.set_pan(1, 1.0); // transparent loop on the right + b.set_darken_hz(0, 1000.0); + + const double f = 6000.0; + double l = 0.0, r = 0.0; + b.record(0, true); + b.record(1, true); + for (size_t i = 0; i < at(0.5); ++i) { // the same phrase onto both tapes + const double t = static_cast(i) / k_sr; + b.process(0.6 * std::sin(2.0 * 3.14159265358979323846 * f * t), l, r); + } + b.record(0, false); + b.record(1, false); + + std::vector yl(at(1.0), 0.0), yr(at(1.0), 0.0); + for (size_t i = 0; i < yl.size(); ++i) { + b.process(0.0, yl[i], yr[i]); + } + + // Predicted shade at 6 kHz for a 1 kHz one-pole (+ the wear DC blocker, ~1 up there). + const double a = 1.0 - std::exp(-2.0 * 3.14159265358979323846 * 1000.0 / k_sr); + const double w = 2.0 * 3.14159265358979323846 * f / k_sr; + const double re = 1.0 - (1.0 - a) * std::cos(w); + const double im = (1.0 - a) * std::sin(w); + const double predicted = a / std::sqrt(re * re + im * im); + + const double shaded = goertzel(yl, f, at(0.25), at(0.75)); + const double transparent = goertzel(yr, f, at(0.25), at(0.75)); + const double measured = shaded / transparent; + INFO("6 kHz through the 1 kHz shade: measured " << measured << ", predicted " << predicted); + CHECK(std::abs(measured - predicted) < 0.2 * predicted); + CHECK(transparent > 0.5); // and the transparent loop really is untouched +} + +SCENARIO("a length change is a splice: phase re-wraps and never rewinds") { + loop_bank b = make(); + b.set_loops(1); + b.set_length_seconds(0, 1.0); + + double l = 0.0, r = 0.0; + for (size_t i = 0; i < at(0.9); ++i) { + b.process(0.0, l, r); + } + REQUIRE(std::abs(b.phase(0) - 0.9) < 1e-9); + + b.set_length_seconds(0, 0.5); // head at 43200 of 24000: re-wraps to 19200, not to zero + INFO("phase after the splice: " << b.phase(0)); + REQUIRE(std::abs(b.phase(0) - 0.8) < 1e-9); +} + +SCENARIO("unprepared, the bank emits silence") { + loop_bank b; + b.set_loops(2); + double l = 1.0, r = 1.0; + b.process(0.7, l, r); + REQUIRE(l == 0.0); + REQUIRE(r == 0.0); +} From 153a93d6ec3588aa6fc60f96f7226e8fc2ffc2f0 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 12 Aug 2026 01:30:33 +0000 Subject: [PATCH 4/9] Reach tap.airport~ from the verification layer C ABI section, ctypes bridge class (Airport, with per-loop sequence setters on the Multitap template), and the executed airport.ipynb: bit-exact returns on the loop grid, the 2.5 s lcm of a 24000/30000 sample pair confirmed by composite_period_seconds and by the rendered coincidence raster, an airport-scale seven-loop bank whose composite period overflows to infinity, the per-loop shade measured on the analytic one-pole transfer (0.169 vs 0.169), and two minutes of "2/1"-like material rendered and embedded. Notebook audio previews are embedded decimated (16 kHz) to keep the executed notebooks near house size; discreet.ipynb re-executed the same way. Full-rate listening copies come from the render tool. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_016zgrm1MGS1eir4hCfZBJaR --- notebooks/airport.ipynb | 388 +++++++++++++++++++++++++++++++++++ notebooks/discreet.ipynb | 78 +++---- notebooks/taptools_py.py | 89 +++++++- tools/capi/taptools_capi.cpp | 73 +++++++ tools/capi/taptools_capi.h | 24 +++ 5 files changed, 613 insertions(+), 39 deletions(-) create mode 100644 notebooks/airport.ipynb diff --git a/notebooks/airport.ipynb b/notebooks/airport.ipynb new file mode 100644 index 0000000..997dd8d --- /dev/null +++ b/notebooks/airport.ipynb @@ -0,0 +1,388 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "103df388", + "metadata": {}, + "source": [ + "# tap.airport~ — the loops, measured\n", + "\n", + "The \"2/1\" tape system from *Music for Airports* (`taptools/airport.h`): up to eight\n", + "free-running tape loops of unequal, incommensurate lengths, each holding one recorded phrase.\n", + "The phrases drift in and out of coincidence; the piece never repeats on a human timescale;\n", + "**no setter ever resets a phase**, because the free-run *is* the composition. Every trace\n", + "below drives the **shipping C++** through `tools/capi` via ctypes.\n", + "\n", + "Sections: **1** record and return · **2** incommensurate lengths and the composite period ·\n", + "**3** the per-loop shade, measured · **4** two minutes in the terminal." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4eea065d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:30:17.566485Z", + "iopub.status.busy": "2026-08-12T01:30:17.566295Z", + "iopub.status.idle": "2026-08-12T01:30:17.902742Z", + "shell.execute_reply": "2026-08-12T01:30:17.901310Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import taptools_py as tap\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.2),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.3,\n", + "})\n", + "C = tap.PALETTE\n", + "sr = 48000.0\n", + "\n", + "def punch(bank, loop, phrase):\n", + " \"\"\"Record a phrase onto one loop at wherever its head happens to be.\"\"\"\n", + " bank.record(loop, True)\n", + " bank.process(phrase)\n", + " bank.record(loop, False)" + ] + }, + { + "cell_type": "markdown", + "id": "bbcb2e90", + "metadata": {}, + "source": [ + "## 1 · Record and return\n", + "\n", + "A click planted on a 0.5 s loop returns every 0.5 s, bit-exactly — the playback path is\n", + "bit-transparent at the default (ceiling) darken, and the loop replays the *same* imprint\n", + "every pass, so there is no generation loss to model. The head's phase advances by exactly\n", + "the samples processed, through any setter traffic. (Kernel scenarios: *\"a recorded phrase\n", + "returns every loop period and no setter resets the phase\"*, *\"record off freezes the tape\n", + "bit-exactly\"*.)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d66f190d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:30:17.905454Z", + "iopub.status.busy": "2026-08-12T01:30:17.905188Z", + "iopub.status.idle": "2026-08-12T01:30:18.031537Z", + "shell.execute_reply": "2026-08-12T01:30:18.030403Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bit-exact returns at samples: [23999 47999 71999 95999] — spacing: [24000 24000 24000]\n", + "phase after the render: 0.400042 of the loop\n" + ] + } + ], + "source": [ + "b = tap.Airport(sr, 2.0, smooth_ms=0, lengths=[0.5], pans=[-1.0])\n", + "click = np.zeros(1); click[0] = 1.0\n", + "punch(b, 0, click)\n", + "yl, yr = b.process(np.zeros(int(2.2 * sr)))\n", + "\n", + "t = np.arange(yl.size) / sr\n", + "fig, ax = plt.subplots(figsize=(9, 2.4))\n", + "ax.plot(t, yl, color=C[0], lw=0.8)\n", + "for k in range(1, 5):\n", + " ax.axvline(k * 0.5 - 1 / sr, color=C[3], lw=0.8, ls=\":\")\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"left bus\")\n", + "ax.set_title(\"one planted click, returning on the 0.5 s grid (dotted)\")\n", + "plt.show()\n", + "\n", + "returns = np.flatnonzero(yl == 1.0)\n", + "print(\"bit-exact returns at samples:\", returns[:4], \"— spacing:\", np.diff(returns[:4]))\n", + "print(f\"phase after the render: {b.phase(0):.6f} of the loop\")" + ] + }, + { + "cell_type": "markdown", + "id": "db91e4bf", + "metadata": {}, + "source": [ + "## 2 · Incommensurate lengths and the composite period\n", + "\n", + "Two loops of 0.5 s and 0.625 s (24000 and 30000 samples, gcd 6000) realign only at their\n", + "lcm — 2.5 s — and the kernel's `composite_period_seconds` says exactly that. The raster\n", + "below marks every return of each loop: the coincidence pattern (bottom row) repeats at 2.5 s\n", + "and at no shorter lag. Stretch the lengths toward true incommensurability and the composite\n", + "period leaves the human timescale — that is the piece." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b29fba37", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:30:18.033695Z", + "iopub.status.busy": "2026-08-12T01:30:18.033504Z", + "iopub.status.idle": "2026-08-12T01:30:18.222863Z", + "shell.execute_reply": "2026-08-12T01:30:18.221775Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "composite period: 2.5 s (lcm of 24000 and 30000 samples)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "seven airport-scale loops -> composite period: inf hours\n" + ] + } + ], + "source": [ + "b = tap.Airport(sr, 2.0, smooth_ms=0, lengths=[0.5, 0.625], pans=[-1.0, 1.0])\n", + "click = np.zeros(1); click[0] = 1.0\n", + "punch(b, 0, click)\n", + "punch(b, 1, click)\n", + "print(f\"composite period: {b.composite_period_seconds} s (lcm of 24000 and 30000 samples)\")\n", + "\n", + "yl, yr = b.process(np.zeros(int(7.5 * sr))) # loop A on the left bus, loop B on the right\n", + "hits_a = np.flatnonzero(yl > 0.5) / sr\n", + "hits_b = np.flatnonzero(yr > 0.5) / sr\n", + "fig, ax = plt.subplots(figsize=(9, 2.2))\n", + "ax.eventplot([hits_a, hits_b, np.concatenate([hits_a, hits_b])], colors=[C[0], C[1], C[3]],\n", + " lineoffsets=[2, 1, 0], linelengths=0.8)\n", + "for k in range(1, 3):\n", + " ax.axvline(2.5 * k, color=\"gray\", lw=0.8, ls=\":\")\n", + "ax.set_yticks([2, 1, 0], [\"loop A\", \"loop B\", \"sum\"])\n", + "ax.set_xlabel(\"time (s)\")\n", + "ax.set_title(\"returns of two incommensurate loops: the pattern repeats at the 2.5 s lcm\")\n", + "plt.show()\n", + "\n", + "# The published-scale version: seven loops in the 17..31 s range, mutually coprime in samples.\n", + "b7 = tap.Airport(sr, 32.0, lengths=[17.8, 19.1, 21.3, 23.9, 26.2, 28.7, 30.9])\n", + "print(f\"seven airport-scale loops -> composite period: \"\n", + " f\"{b7.composite_period_seconds / 3600.0:.1f} hours\")" + ] + }, + { + "cell_type": "markdown", + "id": "812af78b", + "metadata": {}, + "source": [ + "## 3 · The per-loop shade, measured\n", + "\n", + "`darken` is a playback tone per loop — not generation loss (a frozen loop replays the same\n", + "imprint forever). The same 6 kHz phrase on two loops, one shaded at 1 kHz and one left\n", + "transparent, panned to opposite buses: the level ratio between the buses lands on the\n", + "analytic one-pole transfer. (Kernel scenario: *\"darken shades one loop's playback and only\n", + "that loop's\"*.)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dff92d50", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:30:18.225226Z", + "iopub.status.busy": "2026-08-12T01:30:18.225028Z", + "iopub.status.idle": "2026-08-12T01:30:18.419755Z", + "shell.execute_reply": "2026-08-12T01:30:18.418607Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6 kHz through the 1 kHz shade: measured 0.169, predicted 0.169\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "b = tap.Airport(sr, 2.0, smooth_ms=0, lengths=[0.5, 0.5],\n", + " pans=[-1.0, 1.0], darkens=[1000.0, 20000.0])\n", + "tt = np.arange(int(0.5 * sr)) / sr\n", + "phrase = 0.6 * np.sin(2 * np.pi * 6000.0 * tt)\n", + "b.record(0, True); b.record(1, True)\n", + "b.process(phrase)\n", + "b.record(0, False); b.record(1, False)\n", + "\n", + "yl, yr = b.process(np.zeros(int(1.0 * sr)))\n", + "\n", + "def tone(x, f):\n", + " n = np.arange(x.size)\n", + " return 2.0 * np.abs(np.dot(x, np.exp(-2j * np.pi * f * n / sr))) / x.size\n", + "\n", + "a = 1.0 - np.exp(-2 * np.pi * 1000.0 / sr)\n", + "w = 2 * np.pi * 6000.0 / sr\n", + "predicted = a / np.abs(1 - (1 - a) * np.exp(-1j * w))\n", + "measured = tone(yl, 6000.0) / tone(yr, 6000.0)\n", + "print(f\"6 kHz through the 1 kHz shade: measured {measured:.3f}, predicted {predicted:.3f}\")\n", + "\n", + "freqs = np.geomspace(100, 20000, 200)\n", + "H = a / np.abs(1 - (1 - a) * np.exp(-1j * 2 * np.pi * freqs / sr))\n", + "fig, ax = plt.subplots()\n", + "ax.semilogx(freqs, 20 * np.log10(H), color=C[0], label=\"analytic 1 kHz shade\")\n", + "ax.plot([6000], [20 * np.log10(measured)], \"o\", color=C[1], ms=7, label=\"measured, 6 kHz\")\n", + "ax.set_xlabel(\"frequency (Hz)\"); ax.set_ylabel(\"gain (dB)\")\n", + "ax.set_title(\"the shade is a one-pole playback tone, nothing more\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "17206ba1", + "metadata": {}, + "source": [ + "## 4 · Two minutes in the terminal\n", + "\n", + "Seven loops, lengths mutually drifting, each holding one soft chord-tone phrase (an \"aah\"\n", + "of a few harmonics with a slow envelope) recorded once — then the machine simply runs. Levels\n", + "and pans place the phrases across the field; two loops carry a gentle shade. Nothing in this\n", + "render repeats: the composite period of these lengths is measured above in hours." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1f9000b2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:30:18.422239Z", + "iopub.status.busy": "2026-08-12T01:30:18.422057Z", + "iopub.status.idle": "2026-08-12T01:30:22.719861Z", + "shell.execute_reply": "2026-08-12T01:30:22.715630Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuAAAAECCAYAAAC/umIdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAOxAAADsQBlSsOGwAAtZxJREFUeJzsnXmYHFW5/79VvU93zz7Ts2TW7IGQDQghLCGgIOtFUEAU2QX1JyjeC4ILoIioXEFRBBWEqyiI7Mi+EwhrIAmEZLLOkpmetXum96XO74/qU129V3dXLzNzPs+T58n0UlVdy6m33vN9vy9HCCFgMBgMBoPBYDAYRYEv9QYwGAwGg8FgMBizCRaAMxgMBoPBYDAYRYQF4AwGg8FgMBgMRhFhATiDwWAwGAwGg1FEWADOYDAYDAaDwWAUERaAMxgMBoPBYDAYRYQF4AwGg8FgMBgMRhFhATij4ExOTmLjxo3wer2l3pSSMTU1hc2bN2Pjxo3w+XxZfXd8fBwbN26E3+8v0NaVN729vdi0adO0XX6pt0Hpsrdu3Ypdu3YVZBsY0w92PgC7d+/Gxx9/nPFz5TCGMKYfLAAvYxwOR04BW7nx7rvvYs2aNQUbzMt9P/3lL39Bc3Mzvva1r+HKK6+E3W5P+rlUv+Pll1/GmjVrMDg4WLBtLOd9+Nvf/hannHLKtF1+qbdB6bLPP/98/OQnPynINjCmH7PpfNi7d2/SAPrnP/85zjrrrIzfL4cxZDrxwQcfoK+vr9SbUXJYAF7GvPnmm1izZg327t1b6k3Ji6qqKqxevRoVFRUFWX6576cf/OAH+M53voOPP/4YGzduREdHR9LPlfJ3lPM+7OjowMqVK0u9GQWlkL9xNuw/BiMffv3rX+P000/P+fvsGsuO448/Hr///e9LvRklR1vqDWAkZ2xsDNu3bwcAfPzxx3A4HACAgw46CJs3b8b8+fNRV1cHAAgEAvjwww/R0NCAuXPnSsvYvHkzLBYLuru7pdcEQcCOHTvg9/uxYMECmEymjNsyPj6OHTt2YMWKFdDr9di+fTsqKirQ3t4ufcbj8WDnzp1obW2VtouycOFC3HbbbWhubk5YnsFgwI4dO0AIwcKFC2O+Z7fbsWfPHhx22GExr/f19WFkZAQrV65MuZ9WrlwJvV4vfae3txejo6Po7OxEbW1t0t85NDSE4eFhdHZ2orKyMuN+AdLvz+HhYWzfvh0jIyMIh8PYuHEjrFYrDjjggITlpPsd8aTaX3KU/F4l61a6D+OP6c6dO+Hz+XDggQdi9+7dmJqawrJly+Dz+dDT04O2tjZUV1dL3x8ZGcH+/fuxaNEiGAyGmGWfdtppOOKII6S/5cvz+/3Yvn07GhoapPOLMjg4iH379gEAtFot2traYLPZ0u6LXBAEAT09PSCEYMGCBeD5xLyGx+NBT08PjEYjFixYAI7jVPmNSrYhftkUus/nzZsHs9mc8veFw2Hs2LEDgUAg6fFRc1uVrpN+pre3F16vF/PmzYs5V9OhxvHK95zO5nfGo/S8zva4KD0fkjE8PIzBwUHpu1u3boXJZIq5HwGZ96tSsv1t6da7a9cu2O12+P1+bNy4EQBQUVGBgw46KGYZ6daT7/WrdP+l2wc7duxATU0N5syZI33G6XRiz549sFqtSZf13nvvobm5GXPmzIHdbsfQ0FDauCDT8rZu3QqXywUAsFgs6OzshMViifnMu+++i1AohP3790v7u62tDa2trQAAt9uNvXv3orKyEm1tbSl//4yAMMqSF154gSxcuJAAIMuWLSOrV68mq1evJna7ndTX15Mf/ehH0mdffPFFAoAccsgh0muBQIBUVFSQX/3qV9Jrjz32GGlpaSH19fWks7OTVFRUkJ/97GcZt+Vf//oXAUA2btxI1qxZQxYtWkT0ej255JJLCCGEPPLII6S7u5vMnTuX6HQ68pe//CXhtwAgW7ZsiVnee++9R4488kiyaNEiYjKZyKpVq8jIyIj0vd/97ncEAAkGgzHLu/rqq4nNZku7n4aHhwkhhGzcuJEsXbqUWK1WsmTJEmI0Gsmll15KAoGAtLyBgQFy+OGHk8rKSrJs2TJSW1tLTjvtNDI4OJh2v2Tan4888gg59NBDCQDS1dVFVq9eTS666KKky0r3O5TuL6W/N5t1K10m3ca33nqLrFmzhhx44IHk/PPPJ4QQctFFF5GFCxeSV155hcydO5fMnz+fmEwm8re//Y0QQsh///d/k+7ubtLQ0ECam5vJ5s2bY7bvqquuIq2trdLfdHlvvvkmmTdvHlm0aBHRaDTkG9/4Rsz3/v73v0u/ZeXKlaSqqoocdNBB5L333ku7fLfbTd5++20yMDCQcp9R7rrrLtLY2Ehqa2vJokWLSEtLC3nooYek9wVBID/84Q+JyWQi3d3dpKamhrS1tZFnn31Wld+oZBvilx0Khcjll19ONBoNmT9/PmlvbyePP/44WbVqFTn33HMTll1fX0+am5vJ3LlzSVVVFfnzn/8c8xk1t1XpOp9//nnS3t5OmpubydKlS0l1dTX5wQ9+QARBSFhnNutXerzyPaeV/s5kKD2vlR6XbM6HeEKhELn00kul73Z0dCT9rtL9qhSlv03Jem+88UZis9mIXq+X9utXvvKVrNaT6/WrdP+l2wcvvfQS6e7uJgcffDD54x//SAghZGpqipx33nnEYDCQhQsXktraWrJ06VLyySefxCzDbDaTn/zkJ+Sqq64inZ2dxGazkaqqKvKPf/wj5nNKl3f++edL+3Dx4sVEr9eTc889l0xNTUmfOeqoo4hWqyUtLS3SZ++9915CCCHXXHMNMZlMZPHixaS7u5t0d3eT//znP2n3w3SGBeBlzJNPPkkAkG3btsW8fsYZZ5C1a9dKf1977bWksbGRaDQa4nA4CCGEvP766wQAef/99wkhhHzwwQdEq9WSK664QrpJPfDAAwQA+cMf/pB2O2hwddppp5E9e/YQQsSgjOM48utf/5pceOGFUpD83e9+l1RWVhKn0yl9P1UAfsopp5Dt27cTQgjZt28fqaurI9///vel7ykJwNPtp507dxKr1Uq+9rWvEa/XSwghZPv27aS5uZn8z//8j/S5s88+mxxyyCHE7XZLrz3xxBNk48aNKfeJ0v3p9XoJAHLnnXemXFam36F0fyn9vdmsW+ky6TZ+4QtfkLaRctFFF5GWlhZy8cUXE5/PRwgh5IYbbiAmk4nccsst0uDr9XrJypUryfHHHx/z/WQ3t5aWFnL++edLx+zf//43AUBefPHFlL/R6/WSCy+8kHR1dRG/359y+Zs2bSIAyM0335x2n/3lL38hAMjvfvc76bXh4eGY4//LX/6SaDQa8sQTTxBCCAmHw+TCCy8kBoOBfPrpp3n/RiXbEL/s22+/nRiNRvLyyy8TQgjx+Xzkq1/9Kuno6Ii56d93330EQExQ+NBDDxGO48hLL71UkG1Vss5wOExqa2vJ97//fena8/v95Oabb445rvGoebzyPaeV7lslpDqvlR4XpedDMm677TZiNBrJa6+9RggREz8XXHBBwneV7lelKP1tStf7rW99i3R0dOS8nlyvX6X7L90+OPfcc2PuXYQQcuKJJ5L29nbpNwYCAXL22WeTjo4O4vF4pM+ZzWZy4IEHxlwT11xzDdFqtWTnzp1ZLy+evXv3kq6uLvK9730v5vW6ujpy9dVXx7z27LPPEgDk3XfflV7bt28fufvuu9Puh+kMC8DLmFRB0R133EF0Oh1xuVyEEEIOO+wwcv3115PKykry+OOPE0IIuf7660l1dTUJh8OEEELOO+880tDQIAVRlOOPP550dnam3Q4aXN11110xr69atYoYDIaYLGxPTw8BQB577DHptVQBeHzg/41vfIPMnz9f+jvfAPzyyy8nNTU10n6i/OpXvyJms1m6Wa1atYp87WtfS7sP4lG6P9UMwDPtL6W/N5t1K10m3cbf/OY3Ccu+6KKLCACyd+9e6bWRkRECgBx++OExn/3d735HOI6L2a/Jbm4AyK5du2K+29nZSf7f//t/CeufmJggmzdvJm+//Ta5//77CQDy8ccfp1z+jh07yOrVq8n999+fsCw57e3t5OSTT077GZvNRr70pS/FvOZ0OkllZSW57LLL8v6NSrYhftmtra3kwgsvjPnMvn37CM/zMTf97u5ucuqppyYs79hjjyWnnHJKQbZVyTrpufP3v/897bLiUfN45XtOK9236ch0Xis9LkrPh2S0trYmzOr19/cTjUYT812l+1UpSn+b0vWmC8CVrCfX61fp/ksGXUf8mP3OO+8QAOSBBx6Ied1utxOe52OuG7PZTJYvXx7zuUAgQJqbm8nll1+e9fIIER9yBgYGyHvvvUfefvtt8rWvfY0sXrw45jPJAvDf/e53xGAwpA3oZxpMAz4NWb9+PYLBIN58802sXbsW77//Pm699Va8//77eOWVV3DqqafilVdewdFHHy3pG99//30cfPDBMBqNMcs64ogj8Nxzz2FsbCxBux3PIYccEvN3W1sbpqamUF9fH/MaAPT392f8HatXr475u7OzU9H3lLJhwwbMnTsXW7ZsiXldr9fD7Xajp6cHBxxwAE444QTcfPPNCIfDOP3007F+/fqMumk19me2ZNpfSn9vNmS7zHi9PqWxsTGm+LS+vh5GoxEHH3xwzOfa2tpACMHAwEBa/WNDQ0NMbQMgFkLJK+v37duHSy+9FK+++irmzZsHi8WCQCAAQDw/4zWelPnz50vaxFQMDAygt7cXV155ZcrP9PX1wW63J+ivKysrsXTpUrz//vtp15HpNyrZhngmJiYwMDCQcJza29vR0tIi/T04OIjdu3fjxBNPTNgXjY2NeOONN1TfVqXrrK+vx6pVq/Ctb30LH3/8MU444QSsXbs2rQa8EMcr13M6230bTzbndabjovR8SAb9bvy41NraGvPdfK+DVGT6bWqtV8lYk8v3lO6/dFRVVWHRokUxr23YsAEAYDabE86v2tpabNq0CV/5ylek19asWRPzGZ1Oh1WrVmHz5s1ZL+/RRx/FVVddBYfDgc7OTuj1egwMDMDpdGb8LevXr4cgCFizZg0uvPBCHHfccViyZImS3TBtYQH4NGTx4sVoamrCyy+/jHA4DKPRiEMPPRTr16/HX//6V3i9XmzcuBG33HKL9B2Px5O0sLCqqgqAWPiQKWCsqamJ+dtgMCR9DYAiz+/4INdoNMZ8L1WBTigUyrhsQPQfd7lcSW+68kHvxhtvRFdXFx544AGcd955CAQCOOWUU3D33XejoaEh6bLV2J/Zkml/Kf292ZDtMhsbG5MuJ/48AfI7f5I9IMXvj6997Wvw+XwYGhqS1vPRRx9hxYoVEAQh7fIz4Xa7ASCm6C4ej8cDACnPkz179qRdR6bfqGQb4pmYmAAAWK3WpNtEmZycBAA8++yzeO+99xI+G3/TV2Nbs1nnSy+9hFtvvRVPPPEEfvWrX8FsNuM73/kOfvaznyUdNwpxvHI9p7Pdt/Fkc15nOi5Kz4dk0O8m21/y1/K9DlKR6beptV4lY00u31O6/9KRbLyl59fPf/7zhPfmzp2bcE9LtX92796d1fJ2796Nc845B1dffTV+8pOfSMm/a665BnfccUfG37JkyRJs3LgRt99+O37xi1/giiuuwLx58/D73/8en//85zN+fzrCAvAyJl2F+Lp16/DKK69AEAQcccQR0Gq1OOaYY3DVVVfhiSeegN/vxzHHHCN9vrW1NekTe29vL7RabcrAqZTQzPrExETMoBH/O1LtJ5qNf/3119Ouh+d5XHTRRbjooovg8/nw1FNP4fzzz8e1116LP/3pT0m/U4j9masjAEXp781m3dkuM5mjRCnw+Xx46623cMcdd8QERD09Paosv6WlBRqNRrpJJaO5uRkcx6U8T2jVfyG3IZ62tjZoNJqEmSZCCPr7+7F8+fKYZV9wwQW49tpr89pOpduazTqrqqpw44034sYbb8To6Chuu+023HTTTVi5ciXOOOOMnNZf6OMVvy257Fu1z2ul50M23wWA/fv3S98t1n6NJ5v15jv25oLS/ZeOZOMtHbMfeOCBhAx8MpLtn76+PnR1dWW1vA0bNsDv9+O73/1uzHYlOzdT7e+VK1fivvvuAwBs2bIF3/rWt3DGGWdgZGQkYbZ5JlAed0tGUmgGgj7Jy1m/fj0+/PBDPPHEE1i/fj0AYNmyZaitrcUNN9yA+vp6LF26VPo8ne6UXwx+vx///Oc/ceyxx5blyU0zQe+884702vj4OF544YWYz6XaT1/+8pexceNGaSpNDrVKiv+/0WjEmWeeiZUrV2JgYCDlthVif6Y73kpQ+nuzWXc+yywlWq0WGo1GyjIBYlCR6oFKjsfjwcaNG7F///6Un7FYLDj++OPx17/+NWGfyTNvRxxxBB544AGEw2Hp/Q8//BBbt27FSSedlO3Pynob4tHpdDjuuOPwz3/+E4QQ6fWnnnoq5nharVaccMIJuP/++5M2Z8r22CvZVqXr9Pl8MbNg9fX1UiCb6poth+NFyWff5nNeJ0Pp+ZDqu8ceeywefPDBmNefe+45KWsKZLdflVx7SslmvVVVVTmPu7midP9ly8knn4yKigrcddddCe8JgpDwO5999tkYicjevXuxYcMGnHjiiVktj870yM/Nvr4+PPvsswnfS7a/48+3pUuX4vzzz4fL5cprf5QzLANexhxwwAGwWCy4/fbbcfHFF0On00nezMccc4zkIUsDcI7jsG7dOvz73//GmWeeGfOUecUVV+DBBx/E8ccfjxtvvBGVlZX4zW9+A7fbjf/93/8t1U9My7Jly3D00UfjO9/5DgKBAMLhMP7yl7/g9NNPx9NPPy19LtV+uuyyy/D888/juOOOw9VXX43ly5djbGwMGzZswLvvvou3334bAHDUUUfh6KOPxtq1a1FfX48333wTb7/9Nv7+97+n3LZC7M9Uv0MpSn9vNuvOZ5mlRKvV4txzz8Wvf/1r2Gw2NDU14d5778WKFSsSHuDi2bFjB9asWYObb74Z11xzTcrP3XHHHTjyyCOxZs0afP/734fNZsOGDRvw2WefSTfV2267DevWrcMpp5yCb37zmxgbG8O1116L1atX4/LLL8/7dyrZhnh+/vOfY+3atfjSl76Eiy66CL29vfjPf/6DZcuWxXzuD3/4g3RdXHHFFWhra8PevXvx+OOPY+HChTESN7W2Vck69+3bh1NOOQUXXnghli9fDo7jcM8996Curg6nnnpqXusv9PGi5Lpv8zmvU6H0fEjGzTffjLVr1+Kss87C+eefj/7+fjzzzDNYtmxZzP1H6X5Veu0pRel6DzvsMNx000244447sGrVKpjN5pQ1ImqidP9lQ2NjI+6++25ceOGFGB0dxamnngqj0YitW7finnvuwV//+teYeq5TTz0VZ555Ji6//HIEg0H8+Mc/xuLFi3HxxRdntbzjjz8ezc3NOO+883DttddibGwMt99+O84991w88MADMdt42GGH4cknn8QJJ5yA2tpatLW14b777sPrr7+OM888E/PmzcPg4CBuueUWnHTSSWU5Q68GLAAvY2pqavDoo4/ij3/8I6655hqEw2E8+eSTaGhowLx58/CFL3wBHo8HK1askL5zxhlnoL+/P2Ea1mw2480338Qdd9yB//u//4Pf78fy5cvx17/+NWVnRkpdXR1Wr16d0CRi/vz5CSb7gKgNlheRxHfCTLW85ubmBF3xww8/jJ/+9Ke4/fbbMXfuXPzhD3/As88+i6GhIUX76bHHHsODDz6Ixx9/HE888QRaWlpwxBFH4Oabb5a+/8Ybb+Dee+/Fgw8+iPHxcXR2duLll1/GkUcemXKfKN2fPM9j9erVihrApPodSveXVqtV9HuzWbfSfZhqGwFRJ5gsm3bIIYfENI0ARI1ufNfU+C5zqZa3ePHimL/vvPNOLFiwAA8++CAMBgPOO+88HHbYYXjttddipu/jl282m7F69eqMU+NdXV346KOPpHNAq9Vi7dq1uOeee6TPrFy5Eps2bcJtt92GX//61zAajbjyyivxrW99K2Zf5foblWxD/LJXrlyJt956C7feeituueUWrFq1Cvfddx+++93vxpy77e3t+Oijj3DXXXfhoYcegtvtxty5c3HRRRfh5JNPLsi2KlnnwoUL8eKLL+Luu+/Gb3/7WxBCpKK6zs7OxAOVxfqVHq98z2ml+zYZSs9rpcdF6fmQjJUrV2LDhg249dZb8ctf/hIHH3ww7r33Xhx88MExzXyU7teRkREAwIEHHph2vdn8NiXrPfnkk3Hbbbfhqaeewt///nd0d3fj73//u+L15Hr9Kt1/2ewDADj33HNx0EEH4U9/+hNuv/12mEwmHHDAAXj00UexYMGChG3/7ne/i1tuuQUDAwM49dRT8YMf/CCmqFnJ8qqqqrBhwwb84he/wC9/+Ut0d3fjb3/7G95++23s3LkzZp233norfvazn+GWW26B3+/HZZddJj0YPfjgg3jggQdQU1ODK664AhdeeGHa/TCd4Yh83onBYDAYDAZDAcFgEBqNJkHzu3jxYtx555245JJLslreD3/4Qzz11FP46KOPVN7S8kTt/ZctFosF3//+93H99dcXdD2M5LAMOIPBYDAYjKwZGRnBmWeeiYsvvhhdXV3o6enBL37xCyxYsCDG6k4pk5OTuOmmmwqwpeWJ2vuPMb1gGXAGg8FgMBg58f777+PPf/4ztm/fDpPJhLVr1+Lb3/52RhtDhkgp99/69evxla98RdJ7M4oLC8AZDAaDwWAwGIwiwmwIGQwGg8FgMBiMIsICcAaDwWAwGAwGo4iwAJzBYDAYDAaDwSgis8IFRRAEOBwOGI3GkrScZTAYDAaDwWDMfAgh8Pl8qK6ujrGYjGdWBOAOhwN1dXWl3gwGg8FgMBgMxixgbGwMtbW1Kd+fFQG40WgEIO4Mk8lU0HURQmC322Gz2Vi2vcxgx6Y8YcelPGHHpXxhx6Y8YcelPCn2cfF6vairq5Niz1TMigCc7nCTyVSUAJyuh12A5QU7NuUJOy7lCTsu5Qs7NuUJOy7lSamOS6Z1sSJMBoPBYDAYDAajiLAAnMFgMBgMBoPBKCIsAGcwGAwGg8FgMIoIC8AZDAZjFuDyhku9CQwGg8GIwALwacSOXg++95ud2NnnLfWmMBiMacTmnS6c/v2tePCF4VJvCoPBYDDAAvBpxWsfOvBxjxuvfego9aYwGIxpxK4+LwQCbO5xl3pTGAwGgwEWgE8rptziFDKbSmYwGNng8QkAAPt4oMRbwmAwGAyABeDTiimPGHi7WQDOYDCywO0Txwz7eACEkBJvDYOhLmGB4M5/78f7n06VelMYDMWwAHwaQQNwl4cF4AwGQzk0A+7xCdI4wmDMFLbt8eDhl0Zw+4P9pd4UBkMxLACfRky5QwCYBIVRfKY8IYw6gqXeDEaOeHzRMWNojMlQGDMLOsOzfyTAzm/GtIEF4NMIKQPOAnBGkfn+7btx0U+3Y3ySBeHTEZoBB4DhcXYMGTMLnz96fn/wGZOhMKYHLACfRkQ14EKGTzIY6kEIwZ4BL1zeMJ5+c7zUm8PIAZYBZ8xk/IHoPfHDz1wl3BIGQzksAJ8mhMJEymKxDDijmPiDBOHI/e3JN0YRDLEHwOmGW5YBZ04ojJmGPADftH0KgsAKjRnlDwvApwlTnpD0f59fQCjMBhhGcZAX/Y45Q3jjI2cJt4aRC16WAWfMYHzB6P3Q6Qpj1wBrVscof1gAPk2Idz5hVoSFZ8QRxM/v3Ydd/bN7MI+fcXn0ldESbQkjV1gGnDGTkWfAASZDYUwPWAA+TZh0xwZBzIqw8DyzYQwvvefAU2+MlXpTSgp92OtsNsJi0uDTPR5s3+cp8VYxskGuAbePsSJMxszCFwnAu1qMAIAPts2OQsxQmLBYYBrDAvBpwlR8AM4y4AXns71ikDk1y/c1Pdfqq7X4wuG1AIBHX2VZ8OlCKEwQCBLwPGDQcXB5w2z8YMwoaAb8sKWVAIAtu9wIBGd+rcqP/rgHX/nhpywIn6awAHyaEN88g91ACwshBNv3idKT2S73ob/fbNLgtKPrwHHAqx84MDHFMqnTAZr9Nhs1sNXpAQB2pgNnzCBoBry5To+5c4wIBAk+2e0u8VYVnu37PHD7BPQP+0u9KYwcYAH4NEFehAkwCUqhGR4PwuES93kpAvAX3hnHf9++qywetNyRc81i0qC53oA1SysRDBFmSZgDH+1wFb2mgLonmYw8mmgAznTgjBkEzYAb9DxWLrQCAD7YNrN14OEwkaSpTncow6cZ5QgLwKcJTIJSXD6TaZxL4bv++Otj+HC7Cx9tL/1NxCXLgAPA6evqAQBPvD7K3HiyYMoTwtW/240f3rmnqOuVZjCMGthqxQCcOaEwZhI0A27U81i5yAIA+HCGN+RxukIgkeHXOcUC8OlIyQLwnTt34tvf/jZOO+00/PCHP8TExISi7z3zzDM44YQT8O9//7vAW1heUAmKJnLE3CwDXlDkRYaleNgZc4ryjlFn6WUe9AHEEgnAVyy0oKPZgDFnCK9vcpRwy6YXg6MBhMIEwxPBop5TVIJSYeSjEhTWDZMxg4hmwDksnWeGTsthR58XTtfMDUwnZEG3Ywb/zplMSQLwgYEBHHbYYfB6vTj77LPx9ttvY/369QiF0p9EY2Nj+M53voNNmzZhz57iZpFKDQ3A6Q2UZcALC9V/A8WXoAgCwbhTvBZGHaUPlKQMeIUYgHMch9OPFrPgj7FiTMXIW8DvHymeZpNKUCqMGthqdQCYBpwxs/AFxFSwQc/DZNBgSVcFCBElXzMVeQA+kx80ZjIlCcBvv/12dHd34y9/+QvOOeccPPHEE9i5cyceeeSRtN/75je/iSuvvBINDQ1F2tLyYSqi8WqOBOCFDArveWIQN/+1F4TMTnmBIBD09EYz4F6/gHARpRaT7rAk7SinAJxmwAHguNU1MJt4fLLbgwFWAKQIue56cLR4AbA8A0414EyCwphJ+GUSFABYtVjUgc9kP/CJSVkGfIol5KYj2lKs9M0338TnP/956W+z2YzDDz8cGzZswJe//OWk3/nnP/+JoaEhfPOb38Sdd96ZdvnBYDAmm+71itlMQkjBg0q6DrXXMxnJgNMbqMsTLshvCQsED74wglCY4OLTmlBfrVN9HaVC6bHps/vg9gmoq9LCFxDg9gpweUOoNBfnchl1RIOj0YlgyR+EqNzJbOSlbTHqeXS1GLF1lwcjjgBaGvQ5L79Q10y5MSwLwAdG/EX7vW65BKUmkgEfD2Rc/2w5LtMRdmxioQG4XseBEIKVCy24B8AHn00VdR/RYzIyEcBfnhjCl45twNw5poKsa2Iympxxukp/nyhnin29KF1PSQLw4eFhNDY2xrzW2NiI4eHhpJ8fGhrCf//3f+Pll18Gx3EZl3/TTTfhhhtuSHjdbrfDZCrMxUAhhMDhcACAom1VimNSzDJajeJNfMzhgd1uV235lDFnNPu6p9eOsH9mBeBKjs27W8QHts4mDfYOCXB7gX19w2is0aT8jprs3BvNKA+NeQtynLNhYtIHAAj4nLDbo9IcvUYM7Pr2j6GpMnfLr0JdM+VG72C0KGxXrxN2e3FuBvaRyLEJ++H3jkGnEWdZ9vUNShnDZMyW4zIdYccmFrdXDEZdk+OwcxpUGQgqjBwGRwPY8tkAGmuKE+rQ4/LqFjdefNcNIezHRSdVFmRdA/boeDIy7iv5faKcKfb1QpO+mShJAK7X6+Hz+WJe8/l8qKioSPr5Sy65BFdeeSXmz5+vaPnXXXcdrr76aulvr9eLuro62Gy2ogTgAGCz2VQ90F6/qLWd11ELwIWgoIXNZlNt+RT7pAuAuC69qRo2m0X1dZQKpcdmaGIAALBsQQ0mXA6MOX0wmWtgsxX23KGEd44BcAAAJqYIGhsbS3qT9YfEbWlrbYDNZpReb6gNAPBDo7PCZqvNefmFumbKjUnPpPR/h5svyPWbDI12CIAL9XUWNDc1wVbnQP9wAERTE3M845ktx2U6wo5NLMGweM+a09KIKosY1qxc5MObH02id8yIpYvqirId9LgMO8UkijdQmPs0AATCAQCiVNLj54o2nkxHin29lHUAPm/ePPT09MS81tPTgzPOOCPhs3a7HU899RT8fj9eeOEFAMC+ffvw5z//GXv27MHvf//7hO/odDrodImZW47jirLz6XrUWhchRJKgNNcbAIjOFIX4LUOyQrEpd3jGDe5Kjs32XvHiWdhZgfciLY3dvsLs72SMybR9voAAj5/AYiqdY6hbpgGX7wNLpCjT5cn/PFH7milHhidkRZijgaL9Vo8/WoTJcRya6vToHw7APh5EV2v6h8rZcFymK+zYRJE04IboGLVqkRVvfjSJDz9z4eQj6ou2LRzHYc9+McE47gwV7PjInU+c7sKtZ6ZQzOtF6TpKEoB/6UtfwpVXXokf//jHaGtrw6uvvootW7bggQceAAC89tpruPnmm/Hss8+ipqYGzzzzTMz3P/vsMxx55JE499xzS7H5RcfrFyAIgNHAo6ZSPGSFasQzJCsOm3TPvsKOUJhIjVIWdphgNopBZjGdUMYcsRXto45gTAFksZFsCCtit4Fq4uO7tDISCQQFjE+GwPMACDAyEUQgKECvK/yDFXVBoeey5AXOmvEwZgCCQOAPihlOvTYa+CxfIM7ebtvrSfq9QhEIEqkwXZ5MURt5EabbKyAYEqDTstYu04mSBODnnnsuXnjhBSxduhSLFi3Cli1b8Mtf/hJLliwBAAwODuK5554DIMpVTjjhhJjvWywWLFy4EIcffnjRt70U0CY8VpNGCsQKZUM4KHNHmJyFgdWe/V4EggStDXpYK7RS0FnMADze+WTUEURnc2qpQCEJhQl8AQE8B5gMsYM73TcsAM8MPab11TrwHIehsQDs4wG0pZGAqIXcBQUAa0fPmFEEQhELQh0Hno8G4A0RA4FiN6kZGAlBiJR3TEwGIQgkZrvUgtoQchxACOB0hVFfzQLw6URJAnCe53H//fejp6cH/f39WLx4MZqamqT3161bl5D1lnPXXXehtbW1GJtaFkxG2tBbzRqYDDx4LmqNp9Goe2HL7ckmi+wtOuUJ4X9+uxvHHlKDM48tjdUk9f9e2CHWI5gj0o+iZsAjzXfmNBrQP+wvqRWhW9YFM35arZIG4KwNckao/KSxRg+9VgzA948UKwCPSFBMsRlw1o6eMROQt6GXYzTw0Go4+IME/oCQ8H6h6B2OjodhQZxJrraqG2oRQuCIBODN9XrsHwnA6QrNKNey2UBJH5fmz5+PY445Jib4BoCmpqaErLectWvXorOzs8BbVz5QuYm1QgOe56SW4IXIgpdSgvLBNhd29HrxwrvKuqIWAtoBUwrAjXRfF68dPQ3AF3WK21DKAJyee8kkMCwDrhxqQWir1aE5YtlYrGY8UgY8MoPBvMAZMwmfP9YDnMJxHCrNxR+j+uyxCYmxAnQzdnlFt7IKI4/GGvF6Zt0wpx9svmIaQANha4X4FE2DIbWzsoGgENP6fLLImc2ePjH4lfubFptoAC4Wp5kLtK9TEQ4TTEyFwHHA/DZxG0qaAffRDHjiUME04MqRZ8BbG8RC6oGR4gTA8k6YAFg7+iJACMHuAS8CweI9uM9WfIHkATggzhoDxb2X9UUy4Hxkc8YLcD+j2e8aqxZVFvE3Fltqw8gfFoBPA2iAQwcT2hJc7Qz48EQQcv/4YgdWPRH3EcdUqCRNBXwBAXv2+8BzwLxI8CtpwH3F2Rfjk+IxqLFqpbbhIxOlz4CbWQY8L2gGvLFWh5b6SAZ8tDgZ8OhDlHi86iq10Go4OKZCUvDCUI+RiQB+eOdeXHLTDvzh4f2l3pwZjz+YXIICRJNWU0WczaUB+JIuMwBgzKl+YEwLMKutWsl2kWXApx8sAJ8GUI2tNRLwFCoDTuUn9Im6mFkDQgh6+sQAPCyUJqjb1eeFIAAdzUaYDJGHnUjhWqFcZ+Khg3V9tQ4NkanF0QJMYSpFakNfkRiAWyUNOAvAMyHPgLdEMuCDxcqAe2kGXDyXeZ5DY+ThbpjpwFVDEAiefH0UF/50OzZuFT3f++zFeciazfhSaMABSBKUYt3LJqZCcLoFVBh5LOkSJYTjBRi/J6QMuA7VkQDc6WLj8HSDBeDTABqM0sGEygHUDgoHIxm5Be3iwFFMDfjwRDBmfY4STKd9Fqf/BoovQaFyk7oqHeoiBTXlUoQZj3x2ICyUvg3yQy8M4+GXRkq9GUmxyzLgzZEM+OBYAEKB9xshROaCEj2GTbVMB64mfXY/rrptF2775wA8PkGSsE15WFay0Ege4PpEQwIpAC9SAmXPgJhE6moxoq5KHL/HC2BFSAPwaqsWVVYagLNzbbrBAvBpAA3ALXEacLUlKNSCcEF75ObhDhdNCrKzL7Zz1EQB/VNTQfXfizqizUmiQWZxpuppwU5dlQ61lVrwvPgwUiotKS0+TVaEqeE5mE08CCmuS0wyRh1B3PXoIO789354iyQXUgohJJoBr9WjwqhBtVWLYIgU/OHKHyQQCKDXcdDKHJMaa5kVoVrs6vfikpu2Y/NON6qtWvz44g78+OJOAGx2qBj4AxEbwqQZcPGeWaxk0u5IA56uFiNqIz07ClGESe+PNZVaKQPOJCjTDxaATwPoIE6f5qUOhCo7c9BsWHuTEUY9j1CYwOsvTuDXExeAl2IwkSwIO2UZcOqCUjQJSiQAr9ZCw3OorSxcFkUJ6VxQAKCyorCNoZSyuccl/X//aHkFlVOeMHx+AWYjL+3HqA68sNvq8SZmv4GoEworxMyfDR87EQwRHLzYgnt/vBBHr6wueuZVzmd7Pfj5vfuKXkRfKtIWYRbZKnXPQCQAbzWitoAZ8NgizEgGnBVhTjtYAD4NmJLZEAKyDLjKgzvVgDfX6WXaueLcQGgBJtWfFzsD7vKE0T/sh07Loasl6s0sSVCKlFWVGrZEBu/6EstQ0klQgOjDYKm7pn4kC8AHyywAHx6PZr8pVAdeaCtCt9QFM3aopwW+rBtm/tCZw6NWVksZV5OBh4YXLfKKPXt175ODeOk9B57fWDo712KSVgNuKW4GnLag724xoa5KXHchXFAmpsRlVlu1qLaKYzDLgE8/WAA+DaA6QhrsFEqXTG8kTfX6ots3UQvCgxdbAUQ1bsViR6+4/rlzTDHtfIvdCTOaARcDJNrNbWSiNIFSuiJMIOrMU2qt68c73NL/B4rkr62U4cixa6yJNskoWgY8if4bkGXAy1yCMjEVxPdv34WNWyZLvSkpofuwuS76gMVxHKwlsOkMhgRs2SleCzQYnOn4FWXAC38MwgLB3kG5BCWSAXeq7+oll6BUmctbA/6vl0Zw57/3l8TZrNxhAfg0ICpBiWjAK9TPgHt8YUy6w9DrONRWaouqnRt3BjHmDImV492idRN9wi8GhBC8+oEDQNT/m2LQcdDwQCBIipLJklxQ4jPgBbCyUgJ98EglQbGWgRXhqCOI/uFo0L2/SO4iSkmeAY8UYhb4YSHqAR6XAa+bHt0wN3w8iU3bXXjoxeFSb0pKpMSFLAAH5J1ii3dtbNvjgT8oBjo0GJzppHdBofexwo+f+0f8CAQJ6ip5WCo0qDDyMOp5+AKCdB2qBc1211i1MVn+ciiGl0MIwb1PDOLhl0Yyno+CQKSHqdkCC8CnASklKCpmZem0fVOtPqaDWDEGrp5+UX4yb45JKlwplgQlLBD85h/9eHrDOHgeWLeyOuZ9juOKKkMZlRVhAii5E0pUgpJ8qCiFz248VP9tjHR6LJa/tlIkBxR5BpxKUEqUAa+v0oHnxQe+cm4WQ2d+evq8BXeMyYVQmGB0IgieAxpqYtuAV1I71yLODm3aHpVi7R30leU+U5t0GfBidsLcHdF/t9nEMZHjONQWSIYiZcCtOmg1HKwVGhBSfkW/bp8gPRBu7nGn/exfnhjEqVdtRZ99djw4AiwAL3uCIQFevwCej2axChGAD8nkJ0Bxq8epA8r8dhOqI5ZKxbAhDAQF3PinfXj6zXHodRxuuLQTB823JHwuKvkpbKDiDwiYcoeh1UQfgKgEZbTEEpRUGnAqQSllESbVf69bWQWgDDPgE6kz4AMj/oJOzUYD8NihXqPhpBbWwyVs9JQJ2oTK4xPK0lN7eCIAgYgzVXLpGlCah9MPZQG4zy+U/QyHGpSLDziV/LQ1aqXXqAxFzWY8voAYE+i0nJQYkQoxy0yGIk+kbd6ZOgAnhOD5jRMIhUnaz800WABe5siz3xwn2ogVQoIyFDeNaq0oYgacBuBtJtRYxQGr0BpwlzeMa+7YjTc/dsJs4vHL/9eNww+qSvrZQjU+imdskma/teB58VhHJSilCZIyuaBI50kJA3Cq/z7+sFrwnNhcJhgqn6yuvAsmpdqihcnAw+0VCvqQGy3CTDx+UiFmGevA5V1gqU1oOUEL1+PlJ4C8PqI414bXF8a2PW7wXFRKNxt04NSG0KhL9AG3yhJJhdYg7454gMsDcKkQU8Xxmyanqi1aKSaghZjlF4BHf/eWna6Ux2DfoF9yi5lNzcFYAF7m0OwJzaYAhQkIB0djC4morqwY2ZudEQeUeW0m1BQhAz4xGcRVv9mJj3vcqKvS4rbvzcPSeYmZb4q5QL7r8Yw5YuUngNwFpVQa8EgAlyEAd5WoCJPqv00GsX6goUYHgZSXvR7NMNtqYov0JB14AWUo1BPdZEwc6m3ToBBzxFHmAXhk39mSBeBFTGIAwJZdboQFYEFHBQ6cK9bS7C1yAL5puwtvbHIUdZ3pMuBGPQ+9jkMwRCQpRKGgDzvttuj4LWXAVZRU0qC2pjIaE2RqR99n9+HeJ4ekGbFiIU+kjTlDKce6D7dPSf8vp7G70LAAvMyhGUiaTQEAcwGcORIlKMWxl5vyhDA4FoBex6HdZoTZxEOn5eD1C9LAqjb3/2cYO/t9aG3U47ffn4/uVlPaz9NpvoJnwCPTlFT3DcTaEBZbzykIRNK9Z8yAl0h7SPXfB841Q6vh0BrRVpeLE0ooTDDmDILjYo8rALTUF96KMF0GnHbDLFeZAiEkLgD3pvl0aRhK4oBCKXYTGKr/XrHAIlmpFrMQUxAIrr97L278y76iZmL9aQJwQDZGFXCbvL4w9o8EoNVwaK6LXmu0pknNDLi8CyalOoMX+N+eGcbfnrHjlfcdqm2HEuJ/dyp5ibx2gWXAGWXDZFwBJgBUGHhwnHhzVavqOV6CUqzqcar/nttqgkbDgeO4gmfBacDzrTNbk04dx1MsCUq8BzggZnCsFRqEwgTOIjfW8PoFECIWN2o0idO7QHSKt1QacKr/XrZAnMFoltxFymMQH3UEQYg4q6GN24fNRbAiTKUBB6JZ23KVoLi8YgMjnVbcbzv7vWUlLQISExdyimmBB8gC8EUWdLWISQVaGFgMhsYCcHnDEITMszr/fnkEZ1/7qSqzL1IjHkPycKayCHaQ9EGnvckQc50XohnPhKwJD6VSyoAn/419Q+L2yd2iigH93bS/h7xhGiUcJvh4R/R1lgFnlA20g5c8AOd5TrqhqjGlRAiRrLRoVq5YFlq0Ac/8tmgWmj7ZTxSggQEQzUjRabtMRCUohb35x3uAU0rVjMeVwYIQKL0NIdV/L58vTrnT87dcMuDJPMApxWjG44mcsxVJjqGttrwDcKr/bq7TY06jAcEQKTtNsxSA1ybLgBfPI3/SHcLOfi90Wg4HdJvR0SSeW312P0Lh4sycyYP9TLMqr29yYMQRxKYdiQFZtkguKLpUAXjhpUD0t8ubuAEF0oDLPMAp1WmKMAkhUuBd7HGRPiwcsVysr0qWAd/R64HbJ0g1MiMTgbKzUywULAAvc2hgQ5/iKWp2w3S6xEyTxaSRCjwlC61CZ8CpBWF7NACnT/aFKsSkgxR9Ks9EoRofxUMD8Pqq2GNdLzXjKXIAnqEAEyi+zlWOXP89v70CANAayYCXixNKMg9wCtWAFzIDTiVEFUmyg8XQoOcDlZ801OikosJyk6GkzYCbi1dH8/EOFwgBlnRVwKjnYTJq0FynRyhMipb13L0/emwyBeBDY+KxVSMDnlmCUngpkNQBszU2AI9qwAshQYk+1KfTgDtcIUmKVuxxkdovHrLYigojj8HRQEJTOercc+iSStRUahEWovVQMx0WgBcQQSB5F+7RADy+E6HkhKJCUJjsJqKmfnFiKoi7Htmf1J85bQa8QAH4pDv5Q00qihWAjyYpwgSiAXixByUavKXyAAfkRZjFz4DH678Bub92mWTAk3iAU6RumAXMSnn9qTPg9dWiLGZ8MlSweot8oA+cYgAuPmCVUyFmIChgzBmCho9eo3KkzGsRrg0axKxYaJVe66Q68CLNGsgz4MNpZATifhPfH1JB7+sLpvYBB+TJpMIdB+qAkpgBj3bDVItkEhTJBSXJPXNgOLqP9xfY9jQemq2vq9ZJhcFb4rLgVDq1cpFFmpUr17oUtWEBeIEQBIITvrMZp121FeE8pgCTSVAAeQY8/xsnDVbkhURyr/F8p4Mef20MD704guv+sCfmRu/1hdE37IeGBzqbowMXnVorhAY8ECLwBQRo+OS62GRYIgFooV1Q4pvwUBpKZEWoJANuNPDQajj4i9QpVE68/huI6qoHRwNl0YREckBJkgFvrNFDq+Ew5gwVrAOch/q4JynC1PAcbHURK8IyzIJHA3B9WQbgUoOlWj00fBILPEnGV/jZoY9oELMwei3QALxYsh0ahALpA6iRCbEuAlArAy4uzKBPUadS4ONACMFuKQMeW9BfadZAw4uJNLXGR0eSIkzJBzzJb5TPgPiDRFVP8kxQDXhtpQ4HzRMDcLkMxR8QsHWXGxwHLF9gkaxRZ4sOnAXgBYLnOZgM+WepoxKU2BuomlnZZF62Gg0Hi0nsrpVvdnNHr3jT7B3y4w//GpBe3zXgAyFi1kAv0+/RqbVCdMOkDyxVMg/VTBQjA04ISeqCApROgiK1oa9IHYBzHFd0v2NKvP4bEDs+1lRqEQyRknUPlZPMA5yi0UQD4ELJQNwpWtFTJCeWMpkxkEOnqhuqdZjXZgLPi8Vu5ZKtj7dujceqsgvKJ7vd+M+GsYQHyxFHEL12UYq1sLNCer2riBlwrz8cI29I52Qhz3oPqlGE6U8vQSm0G82YM4QpdxjWCo2k+abwPCfJUNQqxJyYitgQJnFBSZa0ipcgFetaJ4TEZOsPilj9yjPgn+x2IxgimDvHhCqLlmXAGephUcEuMNqIJ04DXmAJCqDe1B11OuF54OkN43jl/QkAQE8kMJ/XVhHzeckFpQC2UbSQUqn8BChOJ0yPT4DPL8Bo4GGOC5ZKVYQpeYAnyZ7KsZqK6/YAJNd/U6i0Y6AMdOBSF8ya5EFaoYtGU7Wip8hnDMoNuQbcqOfR2WyEIETHk1JjT+MBDgBmIw+eF2VAari33HJfL279ez/++Mj+GBkBzX4fNM8c48BBA/A9g4XfX/sG/SAkOntpT5MskBf9jk4E8y4SpRIUUyoNeIGLYWnmv7vVmDSpQ9vRj6k0gzmRpAgz2gkzseHQQCQA10caFRVLBz7lCSMUJjAbeRj0PBZ0mKDXcdg76JPqsD6Mm7mhUj0WgDPyRo0gOdqIJ5UEJf+gZzCFl60aVoTjziDGnCGYjTy+9aVWAMBvHujH4Kg/2gGzPXbaLuqCov6AOeURByelBZhAcWwIJQeUqsTMfKm6YUpt6NNkwIHC3+CSkUz/TSknHXi6DDhQ+EJMjz99BjyfAPwX9/Xiilt7CiY9GpVpwAGUnQwl1bhJ4ThONZcgrz8sPVD+++VR/O2ZYem9TZEmJstl8hMAaLMZoOHFgKtQEicKDUJXLLBAp+Uw5Q5LTaDikWfHBYKEorxsIIRIv02fIgCvKnAGnEp84vXfFCkDrsL4HQ4TTLrD4Ljo7wLE7L/RwCMUJtKsF4U+3C+bL54fAyoU5RJC8O+XR2L8u+OhGf/qyIOCTstjcWSGhmbBP/xMPHdXRM5d+jCbroZgJsEC8AKiRpA8GQlqrOYUAbiaGfC4G4kaPrY9/dEul6cdVYcjllXB7RNw0z29+CxyI50/JzYAL6QPeD4Z8EJqwKMOKImBmhSAl6ELChB90CymBCWZ/pvSUiZe4C5vGG6fOKsR/wBNKWQznrBA4PML4LjUBWr5rP+1Dx3YusuD9z6dyvzhLCGEYJhmwKvF41luAXimDDgg86DOM/jrs4vHx2zkwXPAfU/b8ew7HhBCJCu/lbICTEAMeObYDCAE2DdUWBkKLcCcO8ckPWym0vFSB5To37lfp8EQASGATssl1eEDhW8WRiUe7U0pAnBqRahCQonOCleZtQm9GZI14yGESA9uhx4gnh9qPOzvG/TjDw/vx+3/7E/5mQmZ/ptyUOQhYPNOF1yeMHp6vdBqOCyN6MMlCUqZWqOqjfIohJE1NHDJJzBJ1gkTkGXX8wx6wgKRnjbjA3A1/FPlbeY5jsNVX52DHb0ebNsr3kQ5DuieEztwRW0I1Q84pzw0AFeeAS9GJ8xUDiiAuK06LQe3T4DXF4YpgyRELaIuKOnXV1lR2EYXb212YswZgk7LQafloNVw+GCbGHTI9d+UcvEClzugpKo3KKQVoJfqvw08+BTBSa4Z8EBQQCDS2vvl9x1Yu6wqjy1NxO0VJVkmAy9df9SK8LMyCcAzZcAB9Xzye4fEc3nlYitWH2DFr//Wj/97bgrg7RgeD6LSrEmwwAOArmYj9g36sWe/DwvipFpqIrmAtBphq9FjYDgA+0RAKgSVQwPu+modRh3BvAJwqQlPigdMoPCWurSGqjmJFSUA1Eka8PzvZ8kKMClVFg2GxsQgvbVRHAPHnCH4/AIqzRrpAVaNh/0+u/jARYvdk40vtI9HrUwqQwsxt+x046MdLggEOKCrQqqXk2vACSGK67SmKywALyD5SlAEgcgkKLGHStIl59mIZ9QhavBqK7UJRSxqFK9IMpOIzWClWYtrL2jH936zCwIRp0npxUcRCyTF9YbDJGUXxlyQAnCFTXiAqAba7Q0XbFAYjRRgJrMz4zgODTU67B8JYNQZRFuRAvBoBjz9RJmlgE2bdvR68KM/7k36XjL9NyDzAi+xrpk+2CZzQKEUMgPuzqD/BmQB+FjqG2m6ZQPA25udqj8YDssKMOn11t1qgk7LYWA4AJcnnLY4uBgMKciAW1VqAtMbyWB3NBnwhcPr4PKG8cd/D+L/IlKU5QssSY9dZ4sJ+NBZ0ELMeBcQ6nk/nCKwptnN5QssePHdiYSMeDZk8gAHovfOQiUIBlPMIFNoN0w13EeS6b8pyZrx0Ox8a6NBetgfiFgR5nMfo2NrKEwwNhmSnLrk0Iy/vFh0cVcFNLxYx7FhsxNArHOPpUIDs5GH2yfA6QonfdCYSZRMgvLggw9i0aJFMJvNOOyww/Duu++m/KzL5cJPfvITLFiwALW1tTjmmGPw1ltvFXFrc0Mqwszxwvf4BQhEDDTida5qacCTOaBQ1Mgc0IKpeTKf76XzLPj6yU2R/ydmMDUaDpVm0YElWWevfHB5xaxdNhlwvY6HXschLKBgDgxjaTLgQFSaUkwnFCUuKEBhO/5tj8yUtDcZ8PnDanDMwdU4cnkVDjuwEv/vrNaE6wKIasAHi+x5G0+6LpgUGgAPjQXysitNBs2Am9LYbVYYNai2iq4x2RSJye1P/UGCt7ZM5r6hSZAXYFK0Gg7zInK17b3qZsF39Hrw+Gujis8Xry8MpysMnZaLyfDFU6lSExiaAacyhzPXN+D0I6Nj54qFiVIsQFaIWcAAfJS6gJg1qK/SSs4+ySQowZCAUWcQPAfJFzofuYFPCsBTB5PS+OROLFDMF3EGOX0ArmY3zGQOKJQqa2IATvXecxoNqLZoUWHk4fYKeZ+P8kLOVMePbqtcgmIyaLCgvQICAV58VzRjiD93pQe4PGoDpgslCcA3btyI8847Dz/+8Y+xd+9efO5zn8MJJ5yAsbGxpJ//5z//iaqqKjz33HPo6enB4Ycfnvbz5UK+EpRU8hNAPWs8aRo1yfSZJC3I8WKd8oQwOBaAXseh3RY7FXnuCY34zXfn4tLTW5J+t4ZaEaqsA5+S2RBmQ6GdUORFmMkohROKVIRZQg343kExcDhhTS2uPq8dP7ywA9df2ombvtmF4w+rTfqdSrMGZlM0i1Iq0nXBpBj0PGpp9zeVi2wlCVGGzHQuMpT4cefl9xzZbVwG4gswKVJHzL2xAXggKOCP/96P5zeO57S+3z44gN8+OICPdiS2yk7GkCzoSjdroJZFJ9Vwt0dazAPAGevMOPeERsybY8SRK5JLgIrRjGcPdQFpEV1AqONPsgCKeoDX1+gwpzE6+5IrSiQoeh0Po14sUKSNqdRi1BFEWBDHbbmVrpxoN0wVMuBpJCiSFaFszOuXBeAcx0UL1POccZMXuKdyLIkvwqTQpJsgiH0kFnXGzmLOJh14SQLwu+++G8cffzy+8pWvoKGhATfccAMqKirw4IMPJv38xRdfjO9973vo6upCXV0drrnmGkxNTWHbtm1F3vLssOYpQaGZ58okGUhLhTrNYVIVYAL5a8Bp9ntuqylBRsJxHA6ab0lZ4Feobpi5FGECsTKUQiBpwJNM5QGlDcAzFWFa83xQS8feQXGglzdqygTHcWXhb60kAw7IMz7qHtuoBWH6YV7qyJlFAE6TA92tRvA88N6nk6rOVtF9UV8dOy5RHeuO3qi1Xlgg+Plfe/Gvl0bwh4f355Tl7I8UOW7bozAAH0teNxOPFIDnMYsYChMMDPvBcUCbLJHBcRwuOKUJd127UEpYxNNcr4dBx2HEESxYt1pagEmb0KTzcpbuN7V6SbqTT6BFm/CkC8ABdQwFkkFnkNPJzFTNgCeRdVCqkhRh0joYKsvL5VpPhrzAPZWGP1kRJhAtxARETbhOG3vs0s2gzDRKIrDZtGkTzjjjDOlvnuexatUqfPTRRxm/6/F48Ic//AFtbW1Yvnx50s8Eg0GEQtGT0OsVB2tCSMGnpOk6CCFS8ZDLk9vUFw18LRWahO/TgDDXZVMGIwFKU50+YTn05uHMceqO3iTnzjFm/f2aSGvdicmgaseMECIrwuSzWq7UDdMTKsg5JGXAK7VJly8143Gotz8yQbP9Fcb0+8oaeRicyvFclF8z8dAMeEeTIatlN9fr0dPnxcCwX7K+KjY0AGmo0aXd9sYaHT7bKxZtkm71tpU+LFYYE8cPOTQDHt+mOt1xoXKjOY0G1FRq8cE2F17f5MDJR9Spsu1SE56a2OthgawQk27b7f8YwBubnJHtCmPUEUxaS5EKlycsZai3R5abCTpu2mrTH9tKmQNHrtftwLAPYQFoqtPBoONijkumZfIc0NFsxI5eL/bs90qyDzWJtmEXr9HG2ogX+FjiWCXXzTdU68Bzor1qIBhOCMSU4POLx82gTz9GVZo1GHEE4XQFU1qC5kL8/TPZcam2ijVNjqkQQmEhpVuLEuRFmPG/lybMHK7oPYo+WLY2iNsn6cCHc5fnhcIE9onYADzZsmjRaY01dvw5oNsEjgMIEW0r478r9wJX895fjPhPvj4llCQAn5ycRFVV7JRZdXU1JidT6wgHBgbQ0dGBcDiM2tpaPPzww7BYkuvebrrpJtxwww0Jr9vtdphMpiTfUA9CCBwOBwAg6BdP0jGHB3a7Petl9UemDXWaUML3vZHgaMqd+F429A2KGR8D74bdHvvEGfSJf487fTmtY2uPeFO0VQez/r5BK667b/8E7HZ1pqIIIZiMZOmCXgfs9tQepvFoNeJA3z84hjqz8u8p3S6a2Q77J2C3Jw7QWojnwoDdldfxzmabXJEgyzM1hpAv9U0j6BOPz7jDm9O2ya8ZeWHQpFuAYyoEo54DCY4n3S+pqK4Q9+eOveNY2lGaqczBUfGYaQQn7PbUmVWzXtzWXb3jWNKmXsZ+aFgMjDjiT3tcKnTidu7pn4zZx6mOCwAM2kUJCI8AVs3X4YNtwHNvDeOQ+epkwQci+0tL3LDbo8vUg8Co5zAyEcSOXfvx3LtePL3BDZ0WqKzgMTYp4KNPB7F0riHVohPYOxgd9z7do+z62t0rWi9aDIG0nxdC4jEYGc/9ut28XTw+thpOWka6YxOPrYZgRy/w8WfDaLCo/zC6Y584HlabxOufhAk4iIH1wP6hmDqN3b3iZy2GAMZGh1FTyWPMKWBbzyBstdmHI0MjEWmNkP4eY9CJ43fvwCgqDcrPjUzsivweq1Fcf6rjYjVxmPQQ9OwelJJLuTA0GhlHwq6E+zVC4tgxPOaG3W6HQIgkNdHBCbt9ClaD+PeuPidyvY0MjYcgyJQ8vYPJz+0xhzjuhv0O2O2xVqXzWnXYORBEd1Pi9WPUiMe0d/+Uave6bK4XNaBJ30yUJAC3Wq1wOp0xrzkcDjQ2Nqb8TmtrK3w+H6ampvCvf/0LJ510Et58802sXLky4bPXXXcdrr76aulvr9eLuro62Gy2ogTgAGCz2dDm9gBwIBjWwmazZb0szY4xAE401JoTvh8WCIAReAMEDQ2Nit0L4hmbEjWTS+bbEqr5BU0AwDi8fi6n7e8fcQAAVh1gg82W3cDf0sgB8CAEU07rTgYhBG7/CACCrg5bVjKU2iofgAB0xkrYbNWqbA/F6QohLAzDWqFB25ympJ+Z53EDcGLKy6u2P9LhDwgIhYeh03KY02pLO2gF4AMwAV8ot22TXzPy9QzucAEYQWeLCU1NyfdLKuZ36oANHkx6dUXZX/GEwwQTU3ZwHLBwbnNKfSgAdM7hgXc88AYNqm6rVj8CYBJ1NYnjh5xF3S4Ak5hwxx6/VMcFAHjdMIApNNSaceJRNtz7n0/xWW8QGkNtVtnnVEx6HACABd2NsMXVjyzscOPjHjf+7wU/3t7iBs8DP764E+9sncRTb47D6TPBZmtQvK7t+50AxHFwfFKAzlgrOVekYsoXKS7vqE07HswZmwIwiWA49/NwctMwACfmt1dKy0h3bOJZ3M3jjY8HMe7Sq34tBEMC9o+K5/mKA1pgMojneW3VOMacIWgMtTH3lSm/GADOba+BzVaL1gYXxpxuBLlK2GzWpOtIh6lvAoATVVZj2t9WX+MD9jrB69Udv6f8AQBuzOsQf0+q41JX7cSkxweNvjrre6EcT0CMm7ra6xOW0+FxA3DAG9DAZrPBPhZAMDyM2kotOtubAQAL6bXuyv0+0js2BWAM1VYtHFMhOFxIGp9MesTgeV5XU8L499PLazHmDEqSMjkLPB4ATjg8ucUdycjmelEDpQF4STTgy5YtwwcffCD9TQjBpk2bsGzZsrTf02q1qKmpwaWXXor29na8+uqrST+n0+lgMpli/gHik08x/1FtrMsbzun70Tb0moT3tBqxZTkhgNdPclq+2ytgzBkEz4utsuPfp5qySU/22+/zC+gb9kPDA10tpqy/T22WHFMh1Y5HWBD3Fc+JuuVsvksLDT0+QfXzhNpT1VXpUn6GNiMZdQRVX3+yfx5ftA09z/NpP2uVNRtRcxv2DUX139l+t1UqNgoUZX/F/xufFLNENVYtDPrE61f+zybTgKt6DCMFZ2ZT+vW3NIoB7mAW+4rWUlgrtLBWaLH6gEoQArz2oTPv7QYgNeFJNi7Rm/bbW8Ss2n9/tQ2HH1Ql1QnsG/Jntb54DeuOPp/i7zTXG9J+Tm7lmuv+6I3ICNpzuA44jpOcUPYOZv5d2f7rHw4gLIh+9hXG6HkmndPjsee0Xeo5Ie43SQc+ntu5TzXgma4xKqd0ZXEve+UDB266txfBUOr7q7yGKt2yqA58Yiq/MdIxJcYEtdbEewWtA3C6xHvmQETn3doYPUfnNNIeCbmPi7RYm7qX2MfFwlr5Z6Y8YQiCGLskOzYNNXos6jQnXX5TnudEufxTQkkC8EsuuQT/+c9/8Mgjj8DlcuHnP/85JicncdZZZwEAHnroIWi10ezk9773PbzyyivweDyYnJzE3XffjT179mDt2rWl2HzFmPNsliMF4CkyteY8izxfeGcchIh+rMm8tiuMPDQ84PMLWbeb3j3gAyFiFX667F8qClGESQuhrGZN1jMGcs292oxmcEABRC9ZnhP3R0hlu7pkRNvQZz520oOmJwxBUG/b9kUkWMmaeWSi0C3eM0GLCNM5oFDoZ/JpyZ0Mj6ThTz/lXVephU7LweEKSYWbmaDWqnQMWn9INQDg5fcnctxa2bIjTXiMsiY8cuSuCZed0YLPR9xwOnO03KOFdLRYVUmnTaVFmJUquKBEPcCzvw6AWCtCtTWw8QWYlGhgHXtOR7uHisFiU56FmFEXlPTjeS49LR5+cQSvvO9I226dbndTiiY8lKgXeO6FhYSQDI14qA1hRC4p6b+jkpu6Kh30Og6OKeXXejx0TO1uMaLKokEwRBLu0+n8yjNRbRXHoyl3GN48+5yUOyUJwI844gjcfffd+O53v4vq6mo89NBDeOqpp9DQIE4bCoKAcDi64y+44AL87//+L5qamtDW1oa//vWveOihh7B69epSbL5i8nVBoYN2MhcUID8vcEIInt4gTrumKpwSMwe5NTGIb8CTLbRyWs129HRgqsrSAQVQz/YxGdQDPN3UvVYjzgoQok41fSaUOqAA4raZDDwEAinrqgZ7IgWYXVk4oFDqqnRiUJnHjSYZgaCAx14bzdillQYeNgUFX1Lr7kK5oBjSD/M8z0ndHJVaEcafH4cdWAmTgcf2fV7JezhXRiLa0cbq5B1ED1lixcGLLbj09GZ86dio1IQG4L2D2QWa1Abv8IPEuqRMAbjLE4bLG4bRwKPKksEhKE8XFEEg0Qx4U27a5fpqHcwmHpPusBQYqcVumQWhHFpIJ3f2CYYEjDpED3DauIUG4Ll2w1TSiAeQF8Mq//2TkXseLQSPJxgSMBL5PdR6MRXRbpi573+XN4xQmKDCyCf9vRVGHjotB19AgC8gSA4o1O4RiFzrUtF1bvuc6spbGgxoSuF4M57CAUUJPM9Fx8QZ7oRSskY8X//617Fv3z6EQiF8/PHHOOKII6T3zjrrLASD0R2/dOlSPPnkk5icnITT6cRbb72F0047rRSbnRUGndg2OxAkWWeQgahlUqpGKJY8gsJPd3uwZ78P1VYtDj+oMuXncrUi7OkTb2K0cUa2SBlwFW8Yk7IMeLZQF5R8O48mQy5BSYfUjKcIVoRuhR7gFDXs1uQQQqIOKDlkwHmei2bBc7zRJOPvzw7jdw8O4B/PDaf9nJTpU5ABr7YUJuNDH4YqFBzD5ob8AnCDnpfa0b/ygSPbTY1BsiBMYd9YYdTglv83F2d9LrZmqMaqQ5VFA7dPyKphFbWqXLeqGkBmJ5TBsYjzRa0+41Sz2agBzwFun5DTzNWIIwifX0C1VZu1dSqF46IylD0pgkn5+s64+hPc//SQomWnzIAnCcxGHEEIRHwgoI4n+QbgPmpDmOEhk3Y+ziYDTs/xVDMqw+NRT/NkDcHk1EZmN/PJgKezIATE41wl64Yp9wCXQzPiAzl6gdMxoqVBj8YUxy+fDDiQ3spyJlGyADwdHMfFSFCmKxzHRbPUOQTJ1OorVdfGfFrdP/mm2MToC2tq09o/SVN3WTY0oR7gyVqFK4EG4HJLpXxxRgbfXG5kZpU6jyZDsiDMULxGA5JieIFH29ArC8ArVW7GMzEpdtczm3jUp5HmpENtL/CwQPDc2+KsEe1MmIqhceUBOMdxSTOG+eKR2RBmItt9FX1Ai44d6w+uBgC89N5EXtcsbcKTyT89GVQHniprGU9YILBH5CTLF5hRadbA6QpLTZSSYVcoPwHEB0FLHlJEeQv6fOhsFgPkTA15PtnlhmMqhOffUSYlkjLgrbEPycmaqdhlFoQUtTLgxgwyx2x9wAWBSDKrVPuMXuPNCs4DmlwZz6MdvZKgls7IOF0hDAxHNeBy8mnGQwiRZoxa6mUZ8IQAnHbBzG3spjMKLABn5AXV0OYy+EaLMFNowHMM7qc8Ibz2oQMAcOLa5N0EKblkwANBAXv2+8BxwNzW3HSLRj0Pk4FHMERU6z5Jf0OmaeNkFLITJg2o6zNkwOnNKt8pfiXQIrtMbegplorcpEqpoJk6WoCZC5LnrUoZ8A+2TUmzD5kChmgXTGVBZFQHrl4A7pYKaTMP89l2w5Qy4LLzY9ViKyrNGvQO+fHP54dzDsJHJElW5sAmno4sA/AxRxChMEFNpRYmg0Yq8PwsjQxlUCq8U3Zso90wsw++4lvQ5wq9FjIFNDQZMDgayNhYyekKYcwZgtHAJzyMUI23/IFS3oSH0lCtA8+Ls4C5zBIrlqBkeR/z+gXQcpbeIV/EdSwWWjug5EGMBqJjk7lf347I8ai2pD7vaAZ8zBmSPMpbGuIC8Dya8UxMhuDzC7CaNbBUaGIKJuWMZ8jWZyLajIcF4Iw8kDuhZAt9Wk8lmchVA/7COxMIBAlWLbIkXJzxSANXFuvYOyg2jpjTaIBJQfYtFfRJX61CTKoBzycDXhgJSuYiTAAxbgaFRspwKjx+cpcBNdibRwEmhZ7bg3m2XaY881a0zXmmJhH2NB1mkyE1n1CxEDPaCVOBBCXbADzJDIlWw+EbX2wBxwF/fnwIdz0ymFNRbrQJT+4Z8H0KrxH6e2kWkwbg6XTg0cI7ZVnpyorcZhGB5C3oc6FOKgJMP5bKJX/pHkKAqDSjq8WYUNQutaOXXSc0SJNnwDUaTpbtzD449QWVBeDZ1jLJxzF/kEjBtpzBLK7xaAZcBQlKmqwybUe/Y58HYUF8wInvEipJUHJI5NCgnQbxNMGQIEGZotuamyWp3EVnJsMC8AJjMamRAU9+A82lMJAQgqci8pOTj8zctS6X6vF8CzApdDDJVPCmlKk8MuD5FLymgxAiafHifdjj6WoR9yfVXRaSZBnOdFhlHf/UYJ8sA54r9CahRgbc6Qrhrc2T4DlxdiYQJCkLqgghsiJMZQF4Q436NxyvL9rJNBPZS1AiMyRxEqUT1tTiugvaodVw+NdLI/jV3/qy1j7TWYBcAvCuLJ1QBiU7QRqAi9fY9n2pfXzjg/ZMWHNIYlDUyoArbYcuz9Bu35s+AE9VgAmI9yaLSQN/kEiZ26EUMwe0UDkXJxSfn7qgKMuAK5WgxCfMkp1P2Txk06B5fDJ3SeVEGgcUCs2Af7JbbNgTLz8BgJbG3Gtj5AWYQGoXm/E8JShMA85QhVwDt0BQrGTW8JCaGyQsOwcN+NZdbuwb9KOmUitV/adDyoBnmI6Us7NXnQBc7gWuBpN5acALU4Q5PBGE2yugyqLJOF1HdaB9dn/BrQjdWbigADLHnxym2ZOxV4UAXPICV0ED/uK7EwiFCQ5ZYpWOQ7KsGCDOtPiDBBaTRnERK80kDauYAXdnkQGnNmr2sWDS6XY5wZA4NvF88uK3Yw6uwU2Xd8Go5/H8xgn85K69klRACVIAnkNDnw6ZF7iS7Dudpm+OPIDQDHhPryfl94firPQyEdUf5yJBUUcDTt0oMkkg5AH6ZxkD8OQFmBRJhhJ5qEwVsEo68ByCLaUSFClB4FEWAMdnypPNOg4qtCAEAJNBgwqjKKnM1RWNJqLS3SdocL4tcuziCzABwFajh4YXpV7ZXJdAYgZcHijL92v+RZjMBUUxanuLziQsOUpQXDIP8FQa2Fyy60+9KU6jn7CmNmPlNl0/kJ22l2bA5+WbAVfZCYVqGlMVtaajUDaEewboNK4po9bZZNSguV6PUJhIFe6FIlmRXTrUzIATQqISlDwCcFudHjwvBnS56Evl20PlJyccXivdcAdTZOyk7LfCAA0Qb4qAehlwQojUTElJBtyo51FXpUUoTKQiyFTIs9+pztmDl1jx6yu6YTVrsHHrJP7nd7sV2UESQmKa8GRLlUWLmkotfH5BUUGrlM2OHNO6Kh3qq3Vw+4SkLhGEEFnxnUIJSo5Wrk5XCE5XGBVGPu/uokqLAMfjJCjp7u2pCjAp8YV0qQqT6fWUSyGmUh9wnVasKRKEaG1EOuLvqcky4Mk07emQHoJyLMRUVoQpvkev/dbGxG3TaKLNblKNYamIz4CbTRpYzbEzHfJtzcWGEBBnBHlOlGcGQ+rXXZULWQXgW7duxfPPPy/9/fbbb2Pu3LmwWCy49NJLEQqp6zE6E7DkWIQ5mUF+AiBrh5VJd7T48qQMxZeUbItXwmEiDcz5BuC0s1dZZMCN0U6Yajab2bM//U0sHmmKfUBZq9tcoeerchvC3Gsd4hl1BOH2Cag0a3LOoACiJrml3gBCsm/OImf7Pi/27PehyqLBmqWVGZ0bspWfANEMuFrNeIIhglCYQKflFDfCalZYnKVUnrS4y4zbvjcPDdU6bN3lxs1/7c147bh96ZvwKEFyQlFwzJPJSagM5bO9ideY0xWGzy/AbOIVy7OiY2h21wbVf7fZDDkXIlPMJh56HQevX0j7IEQDdJ2Wg9MVTnmOh4XoQ3JXirFLnsWkD3YclygtogFsLgG4PxixIcyQAQeyu5fRc7yjWQw042sKfAEBE5MhaDVcRvcqilIZUCrSNeGhVMfJK5NlwIHcnVDiM+CA3PFG/F3hMIHTHQLHRWWk2aLVcKir0oGQ4tjuloqsRrjLLrsMlZVRz+jzzjsPxxxzDG6//XY8/vjj+Ne//qX6Bk53aJCcbfZD6tqYLgDP0t7qhXcmEAwRHLzYIk25ZiJbDXif3Q9/kKCpTp+zby1F9SLMyD6tzEEDrok0myFqN5uRFTIpIVubtVyh8oVsJShKNZbp2KuCAwrlwLlmAMDHPam72WWCZr+PO7QGOi2vIACPFJtlEYA3yGwI1XjAo8cvlXwtGTSjO5hBspONRWVnsxG/vnIurBUavLV5Evc8kd5fmj6ApGrCo4RsrpF4DTiQvhBTakGvUP8NyK6NLOVZaum/AdHqsi5DBjYUFrOYPCd2RwZSy1C27fHAHyRobdSndOmKFtIFMDIRED3Aq3QJtrf5WBEqlaAAstlcBWMUPccP6DaD40QpkDwTG/X510GjsKtyrcJC2FRIhY3WNC4occF5awqThVx7JAxGPt8sW278A5RoHSw2vEvWYVspkhPKGAvA0dvbi/379+Owww4DIGbD3W437rrrLlx88cX4wQ9+EJMdZ4hQCUq20oVoG/rUN7lsZBGEEDz1RqT4MkXny2RkmwHPtwGPHKp1UzsDnksnTKAwMpRMOsp4aLYpn4yuElyeiIVdlgF4tg2bkrF3UAw88pGfUJYviATgO9xpP0cISTrV6QsIeCXSXv3Ew8XrJmMAHnldqQUhIGpErWaxrbMji3qLVHglC0LlD5vSTVlpBlzhuTGn0YAfX9wBngf+8fwwXkjjMT2SoQmPEqhzTqYMuNcvdobUaWOzmEoC8CaF8hMgGvhlmwFXS/9Nqc2QgZUX+S3ponaMyWfaNm6ZBCB2QE1Fo0wfPDSW6IBCyacdfVSCom4GnN5/66t0aKrTIyxA8tUG5OeB8gexWqkQM78MeDoNuPzexnOxD5ZycmnG4/GF4XCFoNdxqJPNTMZbBtLfl8/sJTA7CjEVB+D9/f1obm6W/n7//fexevVqaDTiST1v3jyMjo6qv4XTHEmnnWMAXpkiuwDIizAzZ2T7hwPotftRbdFijYLiS0o2WQMA2NUv3jTylZ8A0YFGDReUsECiunqFU8fxSIWYKgXgoTBBn90PjotOdWYiW5eHXMnaBcWcnRwqHXsjspxcOmDGc9B8MZO3ZZcrbXHh358dxheu2IJf3t8bM+X5xiYH3D4BizsrpMCO3tRSFWHmIkEBAFtNbNFaPkgFmFnIOJRaEUr1AVlcRysXWfHtL7UCAG79ex8+3ZP8gSifAkyK0gw4zaw1xmUxF7SLY9fOfm9CsTO1bstG359rl1g1M+CALAObIgCkgXltpRYLOyMBeIoM+NuRAHzN0tQBuFyCQq+JZAFrXbUOGl7Un2dbFJhNBrwyi1k6t2z8i4650YeRbCwIKVEryOyv72BIgNcvFj6nk2bJ5Sm2Wn1K+VkuEhSaLW+q08fYTtriMuD5FmBSGmUzKDMVxaNze3s7tmzZAofDAQB4/vnnpWw4AOzbtw8dHR2qb+B0x5Jjh8BMbeiB7FrR08F1js2gqPiSUiXTLyoptqVPv7Yssn+pkIowVciAuzxhEAJUGLmcp8Xy6WqajD67D6EwQXO9HiaD8myihheDJK9ffU9yStat6Cuye1BLB82Ad6mQAbfV6tFUp4fbK0i1CfEQQvDkG2MgBHhu4wTOv/4z3P/0ELz+cEzxpXyZgOjZHU7iRjOcYwAebcaT/w3H46UFmMqDZCpLUypBySa7DgCnHV2PU4+sQzBE8OO79ia9sdKHn4YcCjApNADvHfKllfNQd5yWODlepVmLlgY9AkESo/3ds9+Lf74wDABYkEWH32wCPzlRD3B1AnCatUxViEkDw9oqHRbJ3GDiz/HBUT/2DvpgNvKSxCsZcgmKPYUFIQBoeC4mW54NvmwC8CxmIuj92lKhSfpAl63PP5BfEeaUTPaVTpplrdCAxsbJCjApuTTjSXW9xM9gjOdZgElhGXAZc+bMwdFHH41Vq1bhC1/4Ah5//HGcc8450vtPPPEETj/99IJs5HSGBibuNAH4ho+d+J/f7sLt/+zHU2+OYdset9QdMZ1jB70Bur3hjLrRaBet7J5K9ToeRj2PUJjAq0D7nE+hYzySDaEKLiiTkqY+d+MftbthRh1QlN9gdVoe7U1GEJK5HXquhCPHmuOACoUaYmuOD5rxEBINevJpwiPnoPlikLC5J3nWdWe/F6OOIGortThyRRV8AQH3PW3H16//DB/3uGHU8zhmVbX0eb1OdAwRhOQFQtHp9uxuQGq2o5cy4FlowJXelN1Zzo7I+daXW7F8gQUTkyH86K69CQ+R+XiAUywVGtRVacUGKmlkDen8vOM7Yo47g7j2D3vg8QlYt7IK6w+uVrw9kgQli2vD6wtjeDwInZaLKXjLh0wZWLlzRZVFi+Z6PfxBkjCT8M7WKQCi0028nltOtVULnZbDpDssLSPVQ2kuOnBCSFYSlKgfu4IiTNlsqdQAbX90vM3GgpAyJxIQyzPpSlE6e8vznHTvTeYBTmmu14PjxP2t1NKWZsCpVI0S3w2TtqHPtQsmZTZYEWYVjTz44IO4+OKL0d3djZdeegnt7e0AgPHxcaxYsQLHHntsQTZyOqOkXfxDLw7jg89ceOL1MfzmgX58+1c78a+XRgCkv+A0Gg4VRh4CQcbgWEkFdSqyqeKnfuG5FDrGYzFpoNVwcPuEvGzkgGgXTEuOzgqA+hrw3VIBZnZync4Cy1Bcsi6Y8R3uUlFh5MHz4nmYj0f58HgQXr+AaqtWstTKl2URGUqqQsyNW8SAYs1Blbj+kk785ntzsbDdJGWqjlpZlTATkCpgcHvDcHnDMOi4rB92G2rUy/jQ8aBC4QwGID7wGnQcptzhtIXd2WrA5Wg1HH58cQdaGvTY2efFbf8YiJlZy6cLphwlXWOHkhRgUuQ6cF9AwI/u2ovh8SAWd1Xgf85rV3xdANk3gQGAvojUpbXBkFchmxwqQUnVQGosrnnKohQylI1bM+u/ATEYpA+Vm3eKD7+pmo3logMPhQkEAdDwUDSrK2XAFXQkdXnFfWQxaSRv+T2D0cA5mzb0lLlzTNBqOPQO+RVZcsqRZ+QzUWUVP5OqABMQkwgNNToIgvJ9Hs2Ax/5mSYIS8QKnM9a5NuGJXy7LgEeoqKjAD37wA/z+97+PkZ/U1tbiF7/4heobNxOQbAjTBG1jDvGEPfvzDTju0Bp0tRihiRyZBR3ppzppFjyTLCKfANyaRfFKvoWOcjiOU02GEs2A534zU1uCskcqwMwu00ulGYUKwGn2NBsbOI7jcnZ7kLNHBf/veKQM+E530pmit7c4AUQDioPmWXDH/8zHNV9vw/qDq/H1k5oSvpMqAJfrv7N18Yg248k/4+Px0iY82R1DSYYylnp2JRqA5/YwW2XR4qffEBv1vPjuBJ7eMC69J0lQ8vS97lBgRUgz4MmymFErQg9uua8Xn+31oKlOjxu/0alI7iDHbNKA48T9lqnJEWXfINV/q1OACWS2wZuIPHDSTPmiuFkAQMzMf7TDBY4DDj0gfQAORIMoev9J5Zmdiy+1PxCxIFQ6S2dWPktHi9AtFRq02QzgeTEDTDXnQ2k07anQ63jMbRVnL3f0ZpcFz6Z+qT5y/DoySJey7X47KGXAY89JS4UGZhMPn1/ApDssPeDlrwGn1qzqOEOVI4r3UG9vLx566KG0n+no6MCXvvSlvDdqJiG3ISSEJNyUCSFS5uGrJ9hgigTUgaCAQJBkfOK1VGgw4gjC5QnDlsbaOypByT5rlY12Lh+rv2RUW7UYdQQxMRnKWlMbs12R32/NKwOubhEmnYrMRoICRJ1Q9uYwlakEVxbZFjmWCg2crjCm3OG0VlnpoBnLbPdJOprr9Gio1mHEEcTeQV+M48y4M4jt+7zQ6zisXGSVXud5Dp9bXYvPrU5+UaUqWJQsCLO4MVNoM54RVSQo2bugAOLv2jvow/6RQEono1zPDzmdLUZ89ytzcPNfe3HHQwNY0G7CgvYKSXqXbwZcSSFmfBMeOfPnmMBzYlH5rn5R73zTN7ty0rVqeA4WkwZTHnFmQcnMTq/K+m8gczfMsTj3imQZ8A8+cyEYIjigu0JRMqdRNmYn8wCnRL2klQfg2chPAPl9TIkLSjQDrtfxmNNoQO+QH/uGfGhtMGDKLc5yZSuzWNhRge29Xny21yNZPSohmgHPvL6L/6sZKz5zYcWi9MtvbdDjox2iu8shSzJvg+QB3pB4vTTV6bGr34ehsYCsCDO/a9hk0KDKIt5TJqZC0oPhTELx2bNjxw5cffXVWLp0KbTa5F9bvXo1C8Dj0GlFDbUvIDaYMMXdEN1eMdA2GfiY9/Q6HnoF55tSWYQ6EpT0A1cwJMDjE8Bz2d/4U6GWFeGkVNSaRwBuVE+C4vaGYY9oPNNNFSaj0BKUbNvQUyortBhAIC8dOA2YOlTMgHMch4Pmm/HSew5s7nHHBOB0On3FQoviGzmQOQOejQUhRcqAqzDl6smiDb0cenNN54TiyrJANxXHHVqDrbvcePKNMdz4p3249cq58PjEJjy5yFvkdGaQoBBCZBKUxOvPZNSgvcmIvYM+8Dzw40s685qVsZrFAHzSrTQAF7OSalkQApm7YY7HZcDntZnA8+IsgtcfhsmgkdxPMslPKPJi/LoqXUpXDslZKAu9bzYOKEC2LijismnGuavFKAbggz7JMcdWl/0s18LOCuCNsaQWl+mg15ySDPiC9gpFRcL04W6XgqZuwZCA4fEAOC65jt9WKwbg9vGAZMSQrwQFELupOl1e2McDszsA7+rqwsEHH4yBgQFccskluOSSS9DS0lLIbZsxmE1iAO7yhhMC8GjleW4nq1JZRF4SFIUOF/R9q1m5djgT1SpZEUoSlDwy4DTjp0YRJp0a72g2Zq3xbKrVw6jnMeYMwekKJdzQCSH4ZLcHc+cYFburyKG/L9sAy5Kj24McqQBToS2jUpbNt+Cl9xz4qMeF/1pXL71OA/A1S5VbcwLyADx2+jbaoCP7DHhtlQ58xI4tEBQUd7BMRjZt6OXQgsR009L5FGHG880zW/DZXg96+rz40V17AIjyk3wbMNHp994hP8ICSWiWMjEVgi8gwGrWpAz2Dz3Ain1DPlxx9hwcvNia9DNKiZVnZT63C5EBrzRroOHFbKo/ICQErlLgFLkXGfU8uluM2NnvQ0+fFwd2m/HOJ5EAPI39oBx5BjyZAwrFlkMRpuSAovA6obOymYowgyEBvoBo+UflLZ0tRrz2oRN79vukh9psmjFRksl6lKDGrFM8iyNe75/uzrwt9vEgBCImCZKNS3IrQrVsCOlye/q8+O0/B9DSoIfFpIHZpEGNVYsvrK1N2QRquqB4dJ47dy7eeecdPPHEE+jv78eSJUtw5pln4uWXXy7k9s0I0lkR0gC8PsenO6XdMCUJSgGLMNV0QKGolQGXijDz0IArKahVyu4sO2DK4XkuZYtkQLTSu+LWnbjvKXtO25ZrhlMqNstRAy4I6jugUJZFpnu39Lilor9AUMAH28TCzMMOzC7AigbgsQ+GuVoQAqJUoT6ifR7Ns/1yNAOeZQAuWRGmyYBTfWyeWWpAnOn7ySUdsJg0Ug+BfOUngHjuNtbqEAyRpN3+0jmgUC7+r2Y8+PMlWTUuS0VlFv0UCCGSFjqdlVy28DwnyVDim8EQQpLax8n9wHf0ejExGUJjrU7xuCW/DtJdE3WVWmg1HBxTIcX2qtlKUGiwluk+Js820wfBTllNwVAODiiUtiYDTAYew+PBrBryTOXZwyIZ89tM0Gk57B30ZYwfqF94vAUhhY6H/cN+THnC4Hl14oBFkYeEnj4vXvvQiac3jOOhF0dw16ODOd/fyomsUywrV67En/70J+zbtw9HHXUULrnkEpx99tmF2LYZA71okgVu1GmhNtcAXGGjHxrA5uIsUWlRpp2j71eppP8G5M141CrCLA8JCtV/d+cYaFLnlGQylMdfExtibdo+ldOyc5Wg5GtF2Dfshz9IUFelVT2z0dqgR12VFg5XCPsi0/sf7XDBFxAwb44xa9/pxho9eF58gJY79ETb0Od2PTdGtiPfQsxoBjx7DTiQPhOZjwtK8nUacPXX26S/8y3ApNCgKdlDajr9N0XDc6pNe2fjJOUPEgRDBHodl9MMVjqi3TBjx9MpTxjBEIHZyMcEtDRju32vJ8b9ROkMhdyKM13BIs9zWdvOZStBscqSVemK+lyexPNbasYz6IsW7+aQAdfwnNToaXuKLqPJtymiSVcxANfreMyPNMzbtjd9p+B0+m8gui+2R+oFqi3ahFmnXDj7cw344w/m45Zvd+NHF3XgynPm4OzPNwAAXt/kmPbFmTlHI1u3bsU777yDsbExLFq0SM1tmnFImdMkgUm+eilLmuCeEg4TTHnC4Ljc3ElKmgGvVDkDXiZFmJIHeJYOKJRUHTF39HqkCvvd+31SligbpEYrWUtQlGf57GMBXP+nvfjmL3bg3B9twwU/t+Oin+4AoK4DCkXUgYtZ8M0RO0IpoMhSfgKIFqCNNXoQEhsw5NoFk2JTSQcuOdlkGYDTDPy4M5Sy8Va2XVKVcPhBVTjn+EYA2TW5SUdnGrcgJQG4mmTjEJQsAFSLuhTdMKXsd9wDh1SIuc8bbT+vUH4CUDmR+P9M10S2VoTRJjzKAj2NhoPZxIOQ9PfLZHKPlnoDdFoOw+NBqaFXLgE4EGtxqZRCZMAB4IBu0SHqkwwylGgGPPlvpg9adGZXDf03II7b89sqcPASK9atqsYpR9bh4tOa0Virw5gzhG17spPylBtZRSNTU1O48847cdBBB+HrX/86li9fjl27duH6668v0ObNDCxpAnAqQck105IuuKc43SEQEtEA5uApK908MmTAJQeUNM2DskXSgOfZjEeNDLiShx0lEEKkoCBbD3BKqkLM/8gs3QQB2NWXPsvyyW53gs9qrgFWZRY2Xy++O4E3NjmxvdcL+3gQgRCg03JorNXh5CPzn/JPxrJ54s3m44gMRUk77XTQYJnqwANBAeOTIWh4sb12LqidATdlKUGpMEaLxqmTipxQmMDnFwutTVk0+VHCxac14/7rF+GUo9Q5/h1pnFDoMUtWgFkIrFk4Sak9wyAnVSGmvA29nI5mI4wGHkNjAfT0eWHU81iRhXuHTstLy8zkDGSTGrooC8BpBtyURfF0pYIkwVSSByCNhpMKYrfuErPFuQbgqfzV05GNDWE2LOmmOvD0GfBBKQOe/HqhD1dCZMjI1wElHRzH4cjlYtLk9Y+cBVtPMVB85n744Ydoa2vDk08+iZ///OfYtm0bvvvd76KqqgqhUAihUAiCkH9x2kwknQQl37atSqb9qQVfro1NqhTePKQmPKpqwMX9kr8EhQ6qeWjAs5SgPPjCMJ59ezzh9VFnCFOeMKxmjeTNmy3dLVFNIs1Uev1hvPTeBADggO7MxT79w35ceetOfPOWnpjueO4cfZ7T1TrEQ2d+vnxcA+6/YSH+fHUD/nPbgfjHz5bgqBXVWa1XKfIM+O4BH4bHg6ip1EpTwtkiyTUiNycaNDfW6HOefqX653wz4J4cM+Acx6X1i3bL6gPyLZRMRmujQZWpayA6S5ROgpJrEJUtSpMYQLRrslnlYAuISlDiu2GmkkJqeA4L2qLXx8pFlqyLg1cussJaoZHkDqmgjaucChrlAKJUB1AuQQGUOXqlchyhD3ThSJiT6+yJvBAz1SxTPNk04smGJV1iUmLbXk9aj/pMM0bWCk1MvYkaBZjpoPeINzY5FO/DckTxmTs+Pg6n04lnnnkGp5xyCvR6PXQ6Xcy/z3/+84Xc1mlLuszpmINmwHM7YemAOZamaIvKN3JtDStVj2fUgFMJinqDBA1I9o/4EQzl9oBHCFG3FX2SzGA845NB3P3oIG79W19CALBnIKr/zjWIqanUotKsgcsblgr2XvvQCY9PwJKuCnz+MNG/Ol2W5YNtUxCIeH78/N5eaQDOtQgzm2l2R+QmO6/NhJZ6sTCpEAGdnPYmA6qtWoxPhvDvl8VOs6sPqMzZsaepTswG0aYc+VgQUqhrhHoa8OzP92jL8sTjmGt9QClobzKA54B9Q76ELLiU0SuSBCWb2SGXr4AZ8BRFmBNppJA0Ywsotx+Uc/V5bXjo5iUZE0DWLIu4fVlqwOXrmEzX6TXFA5C88NRszN0qs7FWh2qrFlPusOLGQ9EMuLqBbX21DrZaHTw+IWXTKkJIxgw4x3ExEiO1JCipWNJVgboqLezjQfRkmOUtZxSfuYceeijefvvttP9+97vfFXJbpy3pZCJUi5erBIW6p4ym6G4GRLPHuWbAperxDDePSbf6GfAqixbtNgP8QZKxe9hDLwzj13/rS3iSd3sFCIIYjChpWZwKk4EHzwE+Be3W6UOPQID7nh6KeW9PHg4oFI7jEnTgT705BgA46Yi6aPFUmgy4vDX7Rztc+PszYlV5rhrUaJYvc5CRjy1mrnAch4MiMpTn3xFnCnKVnwAyJ5TIzYkWLubShIdCW3cPT6iTAc+mFT2Fymfis6SA7OGsANlZtTEZNPjC4bUQBOCX9/ciHI6634w4guC5WJu8QqLUgQOQZcALEIDXpni4GkszEysPwA/NIQDnOE5R1jybhm+AOA4Dyl1QYtaRJsueSu7RKZMLNtVn7wFO4TguptOqEgqVAQeiOvBPU+ipxydFy87KNJadQKzGP9dGbErheQ5HUBnKh9NXhqL4zK2srMRhhx2W9t/cuXMLua3TFmsaq8D45gfZosS2zJlnsCPf/nTTVFIb+hwD/VRI0oGdqXVqXn8Y9zw5hGfeGseOuKDT6VJHm87znOQqkUmGIr+JvPahEz190W2KFmDmJn2gdMlkKHv2e7FtjwdmI4+jV1ahs8UIg47DwEgg6cwFIQQf7xD353fOagXHAff/x45N26eiXRSzDcAjN7dMllaALABX+VzJxLLIuUSIqDlflaFbXDqkbpiRwDsfC0IK/e7weDDnqVVBIFENeA46bZq9ShqAF7BAsBB844staKzRYfs+Lx58YRiAOLtAiBh85/NAng1ZtUEvqAY8Ii9KkQFPNhO7dJ4ZZiOPVYssqjnUJENpwzdKti4ogLIsezINOBCbMMlXukQfapQ4oYTCBN5I3UWFynUXgLwQM/n9lTaFSpX9psh93gudAQeAI5dXAwBe/2j6ylBUOZojIyO4+uqr8eUvfzmr7+3ZswdvvPEGRkZGMn5WEAR88skn2LRpEzye6VX5mqpZjtcXhtcvQK/jJIeNbKk0a6DTcnB7hZT+qdE29LldFBqN2EqZkPTB1WQBijAB4KD54gCxRZaxjWfLTjeCIfEi3LIrdiBRMzMvOaH4lM0GUO59MpoFz7UFfTw0I7N7vw9PvylqzY89pAYmgwZaDYd5bdTuKvF62Tfkh8MVQl2VFqceVYdzT7CBEOCme3sxGpE/ZN8JM/P0LiUfX/p8WLbALP1/+QJLQmOsbIhvHmIfy8+CEBDPL5OBh9cv5FzsK/kjG/ic9NT1aSQohQwOC4HZpMFVXxUtDu//jx179nsxGGkyVCz9NyD3Ac/CBSUPuVwqpHb08RlwZ+r24bWVOvzfjYtx42Vdqm+PnGxm0IDcJChKsuzRRlOxY1NjjU5qzJPvuUOdUJRkwOWSGLUa3MmRCjH3JA/AX/3AASBaV5QK+cxfIYswKQfNM6PKosHAcKBgXaELTVZX+FtvvYV169Zh8eLF+N///V+Ew2HcdNNN6OrqwtNPP42LL75Y0XIIIbjooouwbNkyXHnllejs7MTtt9+e8vOPPPIIFi5ciLPOOgvnnXce5syZgwcffDCbTS8pqZrl0Gm/usrcO79xHBeVoTiSD+6OKXG9+QQ7UR14mgDcpb4NIQAsnSsGTVt3uVNm4D/4LBqcf7IrPgOunjY92g1TWQb8sAMrYTTweGfrFD7Z7UY4TCQf6nwDcPr9Hb0evPiuKKk48Yha6f10WZaPd4j7a9l8CziOw3kn2bBsvhkTkyEpOM52utMiKzRLl5EIC0Qq2FV7tiQTHU1G6TzIxk4tGXWVWui0HJyuMLy+cN4WhIB4PUdb0uemA5dmMHLQfwMZJCgFDA4LxcGLrTj5iDoEQwS/vL8PfXbqgFLMAFy5D3ghH3JqrFpwnDgrKJfRjTvT1yJVWbRZST1yIVsJij/iv2/UKb93KimGjWbAY38vz3OStWXeGfBIAL6zzytJozJtj9oOKJTuVhOMeh4Dw4EEu1+vL4yX34/cW9amdydqignACz+uazQc1i4TZShvbJqeMhTFV1QgEMCZZ56J6upqnHHGGfjZz36GE088EXfffTf+9Kc/YfPmzTj55JMVLeuBBx7Ao48+ii1btuCDDz7Ak08+iauuugrbtm1L+vnx8XG89NJL2Lp1K7Zs2YIf//jH+PrXvz5tMuGpOijSwslc29BT6jLIUNTQ29JAyZGmJXwhbAgBcaq4uU4Pt0+QPFjj+fCzaNOZrbvcMQGgqhlwI32YSl+ISQPM9iYDvhhpfX7vk0PoH/YjGCJoqtNn3SQlnmijEbH72IJ2E+a3RbMUi9JkWaj+m3aI1PAcrr2gI2aWJFsJil4nWtiFhag+MxlT7jAEIt5QiiUBoPA8h9PX1aOz2Yh1K6vzXpbUgnk8oEoADuRvRejx0i6YuZ1f0SLMNBrwaZIBp3zji82w1eqwo9eLvz8jSlGKGYDLZ0HTyfjoZ+TfURONhkO1VQtCorITIH83LjXItgjTL5vpUYqSID/qgpJ4v1h7UCU0vDh7lg9VFi2a6/XwBYSkNpkx2xPZH9YCXXNaTVSTHp8Ff/VDBzw+AQd0V2Tsz1DMIkzKUSsiOvCZHoBv374dBoMBjz76KH72s5/hpz/9Kd5991188MEHOOecc8Dzyi+Chx56CF/84hfR0dEBAFi/fj0OPPBA/Pvf/076+Ysvvhjt7e3S38cccwz8fr8i6Uo5kEoDTgswc+2CSalPk7EC8pegAPLq+eSDoyAQaerQqnIADkRlKJt7EqfJxieD2D3gg0HHodoidjvsH44WsUW16flvl+SEojADXmnR4sufa4DZxGPTdhceeUXsUplv9hsQM86NsrbdJ8W1zI420Yi1u5Lrv6kmGhDPox+c3w6OEx/WcgmOLQpkKKWSn1DOO6kJf/nRQlXWT4O4geEARiIPwPm2Um/MohnP0FgA72+bignqpALMHPWidZJVXRoXlGlQhCmnwqjB9yNSFHr+FTMAlzeByTR2uL251WAopa4y9vj6A6LcSavhVE+eZINcgqKkw6EvkLsNYTotfrJGPJRzjm/E07ctRXee9TuATIaSoSFPIQswKUtoIWZcQ56nI30lMmW/gWgGXKflCpatj2f5AgssJg32DvrQZ59+MhTFd6CRkRF0d3dLUokFCxZg2bJlqK+vz3qlPT09WLt2bcxr8+fPx86dOxV9/5577sEBBxwgBfDxBINBhELRm4fXK2ZNCSEFF+vTdcjXY5a1i5e/LjXhqdTmtV31kRvmqCOQdDk0a11l1eS8njppHcmLw1zeEAQSdRpRez8vnWfGcxsnsLnHhS8eE3vOfbhtSvqMyaDBGx85sXWXC3MaxQGBFmFazZq8zwE6re/2ppdZSFn3CtGu6svHNeDeJ+2SU0lXi1GVfdTZbMTwRBBGPY9jVlXFLLOpTgerWYOJyRCGJwJSZnXfoE/Sf7c26GK+s2qxBb++ohsGPZ/T9lkrNBh1BDHlDsU8HMihmbdqizbmepmOhTRU7711lwuCIF4nOm1+5z8tdLOPJ17PYYFg2x6xLfjGrVOSddiapZW49vw2mIwaqT6hwpjb9U6zV+POIARBiFmGFAzkuOxSsmKhBaceVYcnXhevwaZafVF/g7VCC7c3gElXKG2AQjOeYsCefPvyuWZqq3RAvw9jzgAIMUn3ISobKNVx1Wo4VBh5eHwC3N5wxoDTF6l5MuiUX290v0+mkclFOwEn3//p7m/ZHJdFHSa8+oED2/d6cOLhtSk/NyVrQ1+oY7OkS3wY+GRPdPZ4z34ftu3xoMLI46gVVRnXXWnW4KLTmqRZ4mKcR1oNhzUHVeKFdybw+odOfOWE5IWixb7HKF2P4gBcEASEw2E4HA4AkOQf9G8A0Ol0MJvNSb4dSyAQgNEYmwE0Go3w+/0Zv3vnnXfib3/7G1577bWUn7nppptwww03JLxut9thMuX/5JoOQoi0T+jDCn2ad3sFDA4OSYUUffvFwFGv8cNut+e8ToNGvAn37nfCbk888LTiPeidgN2eW1bMoBGPTd9+B+z2xOzB0HjkpmHk8votqWipFpf/0Y4pDA0NxWjmN0S6YS1oBXg+jDcAvLd1FCu6xd89NCruZ07wwOEQs4q5au55iPthcNgJuz21RGBkXLw+hJALdnsIa5cIePglDlMe8fjUmvM75pSmmojW/AA9ppyjmIqbietq0mDzrjDe+XgQhy4Wr7k3PhC3bUGbFsPDw4nLjEij7faphPcyYdCK27OvfxQWXfIM475+8Xw16kKw2+1Jr5npgsUgnk8fbHMAAGos+Z//Ro2YMOgdnJKu17BA8MSbbjz7jgcub/QaN+o5cBzw9pZJfOuX23HV2dUYHBLPSw0XzHlbjHoOvgDB4LADHMdJx2V0XJw5CQddSceBcue0w3m894kGTpcAo8aZ0zmeKya9mNne1z8CLUk9SzIxGems6nXCbk8uucvnmqnQi+fH3v5xzLX5sKtPPIcrTaQgY3c2VBgAjw/Y0zuExpr04cmUS9xPXrcTdoXZz4BXvI9MTAZS/tZJt7h/vK5x2El298tsjkuDVdzvW3dNpt3v+4fE8VrDpd7mfGmwiOfmZ3vcGNg/BK2Gw8MvRDoFH2DApGMEkwqWs34ZAISKeh4d1EnwwjvAy++P4tgVqR+MinmPoUnfTGQ1B/vaa6+hpqYm5jX538ceeyxefPHFjMtpaGhIkI+MjIxgwYIFab9322234eabb8ZLL72EAw88MOXnrrvuOlx99dXS316vF3V1dbDZbEUJwAHAZrPFHGizaRRurwBLVb2kLfOH/AA86Giphs2W+gk4E51tDgAueAJ62Gy2mPeCIQEenx08B3R3NOVcRd3eOg7ABW8ocR0AMO7xABhDTWXy9/OlsZGgvnoSo44g/KQaHU1iMEkIwaf7xGmyow9pRjBM8Lfnd2LXfkHajmDYB8CLOU01qK72JxybbKivIwC84LUVaX+nPyTe2Ntb6mCziTKPc0/Q4o+PDAIAli+2wWbLX4Zy3il1qK4aw2lH1yUtaDxoAcHmXcMYckSPy+6hfQCA1UvrYLOp2/a9vtYL9AbB66yw2aqTf+izUQBO2OrNsNlsKa+Z6cC8DgcAF/YOijf2tqb054WiZXa6AExiysvDZrNhaCyAW/7ai08i08Mt9XoctrQShx1oxdJ5ZtjHg/jhnXvQaw/g+nsckj9uTXXu21JXPYGB4QAIb405LmHiAeBDs60GNltVXr+zVNx1bSP8QZJzY7Jcqa12Y8+gC1pDFWw2a8rPBUIOAEDbnIaUY0Q+10yrjQDwIUhMsNls2DHoBDCBxrr8z918qamcxKjTC52pBjZbetcNgZsCEECTrQ42W+bEHwAYzSEAY/D4kPS3EkLg8YnBY1dHU9YyvGyOS2W1AJ6bQN9wCNU1DSmlNJzWDmAKjXWWgh0fG4DWRicGhgNwhyrR2WDEW1tFueSZx7VmPBal5NhaAX94bBJ7B0MQNDVJpWXFvseoHoDTRjzpqKpSNiCvXbsWzz//PH76058CELPpGzZswAUXXABAzFRv2bIFxx13nPSdn/3sZ7jzzjvx6quvYvHixWmXTztzxiPP5BQSuh75uiwmDdxeAW6vgEqz+LrkglKduwsKIPMCdwYTljPpFp9sKy1aaDS5V7HTdYw7Q0m3lU5NV1m0BdnHtInKy+87sHmnW7Lg6x3yY9QRRLVFi+5WEwQiNmboHw7A6Qqj2qqNykEsWnBcIK/zwCLrhpluGVOS7jx6bE89qh5PbxhHICigrSn3Lphyaip1+PrJTSnfX9Qp3pg+2+sBx4lTp1RHv3yBVfVjRR15xieTnydAtAtmtTW6b5JdM9OB5npxypNKVm11uTfooFA7r+GJIF5534Hb/tEPt09AfbUOV5/XhhULLTHraLNpcMf/zMeNf9qHD7e78OQbosTCbMy9u2h9lU50RXAJMcfFFdEnWysKc50XA7NJC3Nh8zBJkawIPeG0+05eBJjuc7leM3Vx1yit66mryu8+pAa0fsiVYR8BsiJMvUbxdlvNWvC8uI+DIZLQIMjjE8R7iIGHTpvb/VLpcakwatDRbMSe/T7s6vfhgLnJHyJowX+hr7kDus0YGA7g090e9A8HMOUJY36bCQs6lD3clAqDXoPDllbilfcdePMjJ778ucaknyvmPUbpOhQH4LQRjxpcccUVuOeee3DppZfi85//PO6++250d3fji1/8IgDglVdewTnnnCM9tVx//fW4+eab8dvf/hYDAwMYGBgAABxyyCGKg/5SY6nQwD4exJQnjObIa1R7l2/luVSEmcQFheqf8832SM4Ik8llF4XyAJcjD8BPPUrUgVP3k5WLLOB5DjzE4sOPdriwdZcbRyyvihZhquCCYknT1VSOVIQp2x8GPY87r5kPjuOK5v5Bq9t7+rwICwR9Mv9vqpFXk7qq9I48QLQxVLEzkIUg3o4sXwcUQAx+OU60Ibzp3l4AwBHLqvC9c+ektG20Vmhx87e78bsHB6Q6g3w8zulxnHDFutlM1yLMckCJBR4Q3ccFK8KsiiZTgPRNeIpNZRZe4Lk04tHwom3v8EQQo84gWupjNcPSw0+RXH4WdVZgz34fPtvnSRmAF9qGkLKky4znN07g0z0eKTY5aW3uM/PFZN3KarzyvgNPbxjHmcc2FMQvvRCUxMy1ra0Nb7/9NjiOw7333osVK1bg5ZdflrLWTU1NOPbYY6XPj4+P48gjj8S//vUv/OIXv5D+9fX1lWLzc8KSxD0j3y6YlHqZbVh89fiESi2/pQA8hde4s0Ae4HKW0o6YPS7p4Yz6f69aHJ3SPVDmGw7IHg6K5IJCCMGkJ1r4Kcdk0BTcT1dObaUOjbU6eHwC+ux+fETtB+dbCpIJyOTIAwATJXZBUZMqiybGBk2NAFyv46WHE4OOw3e/MgfXX9qR0TNdq+Fw5Tmt+NaXWtBcp8chi1PLHDJBr3fHVIoAfJrZEJYDShw4AkEBgSCBVsPBkIW/dTZQ21vq/Z2uCU+xycYL3JeDDSGAtD776RxQCkG0V0NqJ5RibRNttPPuJ1P4uMcNo57H+kNqMnyrPFiztBK2Wh36h/14a7MStXp5ULI74MKFC3HXXXclfW/dunVYt26d9Pdvf/vbIm1V4YhvxqOm9ZNex6PSrMGkOwzHVCjG1tCpUsOTSrPo2ezyhuELCAlBZDEy4B1NBlRZNBhzhjA4GkBjrV7ys165MGqnJzXu2S1WdEez0Vo4Mzu7pYVaGdL9mgy3V4AgiI4wuU5jqsmijgoMjzvx2V6P1IAnXx/bVGTypAeivvTFbsJTCDiOQ3OdXurEpkYADgBfXN+Aj3e4cPkZLejI4L8bvz1fPKYBXzymIa/10yBtYio2EJJ8wFkGPGto7Y8SD2qLSbmsIluopSyVQI6XUQacJiwmFXiB+yM2hEZ9dvupoUYPwIORicSbQbED8PmRbsW7B1IXkcpdUApJR7MRFUZeOgfXraqaNn7/Gg2HM9Y34A8P78dDLw5LdTDlTumjg1kCzRjR7Acd9GortapMl8h14HIcKk33cxwnDdDjSbKbct/rQiHqwCNZ8J1ufLbXA49PQJvNgEZZ4LO4qwI8B/T0euFwhRAMERh0nCqZ5xprZGp+KvUNQs3GP2pA/Wa37/UkNOBRm7o0bcwpM0mCAsTKUPJpQy/nnM834hff7s4q+FYTOqvmkElQwmECj08Ax+XuMT6bsSrIgEvykwJ2GqV2gxOT4owpnYktZRMeipQBdynPgBt0WWbAa1JnwKNdMIsTeNKeAelmDKM1AYXdJg3PYXFntNhSifd3OXHi4bWwVmjwyW4PPtmV2C+kHGGjaJGQMuCRi4kGKPk24aHUp8g8TqiYbaxN0yGvGBlwQPT6BsROjh9si+q/5ZhNGnS3GhEKE7z7ifgZtbKt0ZtXugA8Uf9dSug056sfOuB0hSP+34VpQiJ/EEzlhTqTJChANAC3mjV56a7LCUkDLpOgUH9xs1EzbTSW5YRUhJlGA+4qQgCo1/GwmjUIC2L3YnkyqNQoeUgBgFCYIBQm4Dmx8Us20GSNPVkGvMg1DtUWsSh00h1GIJi8e3AxGvFQaEOezmaj5A0+XTAZNTjlSPGh4cEXE+11yxEWgBcJevG4pQBc3UEvVSGmU8Vgpz5NdlMu8ygktCPmlh43PtwuBterFiVqXakO/K2PJyPbpc7gZa3QSFX0qQZMZ5EeRpSyoN0Ejoseo+ULCqP/BkTnDaOeh88vwONL3D+hsNgxleMK0zG1FNAAXC35STlApUTyALzYwclMo1JqAqNMglJI6Fg+MhGUkjQ15RCAKyxUlRdgZjuW0Qz4yEQaDXiRMuA8z2XsMu0qUhEmAJywphYHdFfgG19sLrkjTi6cvq4eOi2HtzZPos+eua9MqWEBeJGId8+gMo58CzApdEBNJUGpVqEAMdqiunQZ8O5WE8wmHoNjol0SzyeXU9CK8vcjWXK1Hgx4npOkE6lkKJNFKEjNhgqjRvJNB2Lbz6sNx3Goq452TY1nktYkmLXQzJAsaleruG87SyQXKQS0XbljKtq9NxqcsNtGLtAicGea4LLQbegpNPGzZ78PgiCO2+VQr1KlsAgzFwcUCu0InLQIs0hyDzl1aVzM5LIvcxFm15rq9Pjt9+fj0AMqC76uQlBbpcPnVteAEOBfL5V/Frz0V9wsIV4DPibzXlWDVMVvDpVcUID0EhTqgqKG1V86NDwnZbcFIhYYJstW0EJMqhNUU5suBeApMhbFehjJBmpHCBRO/02pT3OeqOXKU06sXGjBzy7vwmVnNGf+8DTBZNSgwsgjGI4GJYW2x5vp0HPekaZ+pFizDHQs7+kVG4aodR/KF6VFmL4g9QDPIQCvpRnw0hdhArLEVhKLX6nomcm+FPOlY8UC9Oc3TkjyqnKFBeBFIl4DTjPgtSpVnten8F92SBKU/AfYdAV2xQw6aSEmEGs/KKehRi8NtGpvF7XrSpkBj2RvrGWSAQeiOvBC6r8pqeoRgOj5WKXCjEy5wHEc1iytlAp0Zwrx1qM0OGEBeG5YTBpoeLHZSyr5WrEkEDTo6+kTA/By0H8Dym0Io014sg9hrBWiFazbJ0j3Y0ppAvDUGfBiyk9mCu1NRhx+UCWCIYLHXxst9eakhQXgRSKVBrxOpcrzaNATGxQ6pYxj/hdwqsymLyB61+q0XNaerLmwbH60YcGqRamzuUtljQ3UtLyTuwgkoxwz4IcdWIm6Ki1OPqKu4Nq+unQzJTPMAWUmQ4MyehyZBjw/OI6TsuCpbEyLpQGnjie7+r0xf5caq8yuN76nhRyfn0pQsh/LOI6TOaHEZsGL7YICpE9sFbMAcybx5ePELPjjr4/B68/sqFMqWABeJBIkKJILirpFmPKsYyAowO0ToOHVGVCotjc+sKK63kpz4bxr5cxvr0BjjQ6NNTos7krdJvdAWQCuagY8kwa8SAWp2dBYq8dDNx+A805K3bZeLaLNeBL3z0yUoMxUot1vxWNG9cmsCU/u0ERAqrHDTWcZChxw0WPrjQSyat2H8kWj4WA28SAk6rqTDJ/kAZ5bCNOQohCzJBrwyL6Pr98CWAY8Vw6ca8bizgpMucN49q3xUm9OSlgAXiSscY14os0P1Mk8VFk00GmjjXKAWAcUNQJjmiVJCMCLHHBqNRzuvGYB7rxmQdqW7gd0ywNwNTPgEQlKCg34VBlmwItJunb0UhMeFoCXPfFF18XKzs5kqi3KMuCFLriLD7jLRQMOAJW0YVEaL/B8ijCBqBVhfAa8FDKrdDOGxWrCM9PgOA5f/pyYBX/45VGE08ymlBIWgBeJaCt6AcGQAKcrDJ5TLxMoNsqJ1ZKpnW0UK+U5uL1CzLROKSQX1VZtxt/V2WKEOeLYoKbmeDpmwItJuowODTxqZkAXzJlOvDtDKfSxM41MhZjuIsl84qWP5WBBSFHiBe4P5huAi7/fXhYZ8NQBOMuA587aZVU45cg6XHt+e9k6brEAvEgYDTx4XtRL02mvmkp1rdjq4+zf1G75LQ/yx2XygmJ0wcwFDc/h2ENqYDbxmDvHlPkLClGsAZ9BhYbZkMqTHpA1hmIZ8LJHalkeudZdzAUlb+hY7EiR3Y3OMhT21pyQAS8TDTgQTeSks2uks7zGLLtgUqgVYYIEpQQPmdHxkmnA1UTDc7jynDmSJXE5wgLwIsFxnPQUu3fQB0D9wpe6OC9wKduoYrAjFWbJgk+nq3wlF//vy6147FcHqrqvM9sQzvYMeDSjE19IpaYtJqOw0JkMKpdzMwlK3khFmCky4MUqdDUZNDAbo7f/ctGAA1H3qKk0Tih5S1CSFGEGQwJ8AQE8D5iKYCZAqTRroNXEykcpUywDPqNhAXgRoTeu3iGxQ5Pag158IWYhCt6SNQ2gAWehPcBzgec51f1TpQx4kptoMCTA6xcLX+U3uNmEXsejMtLq2hGndS3EQyGjMMRPjTMJSv5UZ5CvFbMTY61M910uLihANJGTrhumlAHPMVCWNOCyDLi8xqGYXSDFmeXIw64zuSTGUsHGy5nI7IwQSkQ0ABcz4GoXvsR7gTtd6kpQ5OsYi5GgUMnF7BgkKs1a8LyYnQiGYjMWcg/w6djKVy1S6RrVlkUxCket7FonhLAiTBXIVIRZTKcZOptp1POoKKNkgZUWYabJgEsBeA42hADQIEtW0QI9l0eIrL/453eq8ZJlwGc25XPVzQJo5kjKgKucdYjPgBdiuj/eGxiQSy5mxyCh4TnpRhpfTFWOHuClIJkvvdq2mIzCYjLwMBk4BEMEk+4w8wFXAakIM0kAHgoTSQJRjH4KNOirqSyvZEGlkiJMKkHJUQNu0POotmgRChNJSuiijiMlGJtSeYGzWaeZDQvAiwi9iPZJGfDCSlAcU+LFW61itlGSoMQE4DTonD1ZzVQyFGqdNZv2RTKSZXTktpisrfL0oMYq3iLGJ4NRj+oCFwjOZKpSPLgDUY29uUgSCDrDofZ9KF9oAD6ZRoLij/iA56oBB6JOKMORlvSlfMCMt/yksAz4zIaNpEWEPll7fOLTu+oSlOrYIkyHqwAa8KQSlNmVAQdSF2KyDLhIMieUCSY/mXbURJx8hieCcEfGrYoCe1TPZGhH4mQSlGLqvwGgLpJEKCf9N5CtBCX3ECa+GU8pHUdS9U5gNoQzGxaAF5H4C1vtAFzuAy4IJCpBUTMDnqRYJOqCMnsCqxprxI4xzopwtjugUOqTeIE7C/BAyCgs1ZEMeL9dlM2ZjXzZeupOBywmDTS8mIQJBGPrR4qtsV86zwyDjsOKhZairE8p1L5VkQQlnwx4xIrQHnFCcZcyAE8yswywRjwzHXYnLCLxA2utys0PDHoeVrMGU+4wnO5QgTPgiRIUNZvdlDtRL3CWAU9GMrcc+kDIHFCmD9UWMcChsrlCt0if6XAch2qrFmPOEBxTIcmNAyi+BGJxlxlP/O/StN2ES0E0A67ABUUNCcp4XAa8TDTgYYFIRbnMe39mwjLgRSR+YC1E9zHqUjIwHIDPL0Cn5VStcLdWRLph+sRumOGwOEjw3OwqrEvVDbNcmxIVm3g5FMAkKNMRqgHfNyhmwGfTNV4oos14khfcFboNvZxyC74BuQ1h5gx4XgF4XDOeUnTBpNQnSWxFawLYrNNMhQXgRUR+86qyaKDTqr/7aeCzs98LQJSfqFnQE98Nc1I2RTabCutqIrrJxACcZcABuRwqun+YBGX6UWONLRxnAXj+pGpHH21DP7tvyzRR5fKGJYvAeHySBCX3e05CEWYpM+DViUWYUf03Gy9nKrP7Si8y8gx4oQpfaOCziwbgBQh25BXbs9X1I7UEpXybEhUT0elEzPJRrSvrgjn9oBIUmo1kWtT8SeUF7pK5oMxmNDwHi0kDQqJBaDxqasCpBKWULigWkwZ6HQePT4DXJ24Ha0M/82EBeBGRX0g0U602Uga8r5ABeFReMFszvlEJSqoizNm1P+LR8Jz0kEkfUiYKUBTMKCxUgkKZ7cGhGkS9wGODSzfzWZfIVIjpi9gQ5iNBqanUQhNJEvgDQkkDXvnM8lhkvGQWhDMfFoAXEfnUltoFmBQagO/ZL04ZFyLYkReMSBnfWRZUZSrCtM7yABxI9KV3RgIOlgGfPlDbPAqToORPtIlXcss5to+jQWeqQkw1MuAankMD1YE7oj73pZJ8SDPLkfGSNeGZ+bAAvIjESFBUtiCk0KAnGBIzBFUFlKCMO4MyC8LZNUhUWbTgOTHjHQpHdYrMhjBKXZwVYSFsMRmFxaDjYgJCFgzkT5WkAY/N7rqK2Ia+3KHjZ6pCTF8w/yJMIOoFPjwewFSJJUDxDmMsAz7zKdmd0O124x//+Af6+vqwdOlSfPGLXwTPJ7+YPv30U9x///3S35deeim6u7uLtamqIR9Y6wqWAY9dbiElKGPOoJT5nm0Bp4bnUGnRwjEVwsRUCA3VOhBCMDVLJTnJqI/ztmUa8OlJbZWW6ZNVJKUG3MP2MSVTN0w1XFAAoJEG4BPBkje9kUs7AcBFDQ7Y+TBjKUkGfGpqCoceeij+8pe/wOfz4ZprrsGZZ56Z8vM6nQ7V1dWwWCy45ZZb0NvbW8StVQ+9jodeJ1ZtFyoDHt/cpxCey3UyacFs1YAD8m6Y4oDp9gkIC4DJwBfE4Wa6Ie/u5vWH4Quob4vJKDzyMcXC2tDnTUoXFB+ToFCiEpTEDHhYIAgExVlHej/NFerDPjweKGkRJpDoBc4y4DOfkoymd9xxB/x+P1599VXccsstePXVV/Hkk0/ipZdeSvr5+fPn45prrsH3v//9Im+p+tCLqb5AAXi1RRvj7VoIbXZdJe0CGZrVvteSDjxyI53NDyPJkN9QJP23yraYjMJDpUQACw7VIJMPOJP5yCQoSYowA7Lsd75jCc2A7xvyQxAAo4EvmTd6vASl1Bl5RuEpSdT0wgsv4L/+679gMBgAAHPmzMHhhx+O5557Dscee2zeyw8GgwiFooOb1ys6ghBCQEhyX1G1oOtItZ7OZiNcHjdaG/UF2RaOEws8hyPNBaotGtXXU1slDghjMhcUa4X661GbTMcmW2ppBtwZBCFEpofXlv2+KAZSO3pHQJolqLYm7hu1jwtDHegxkReMm03lf52XO9URhw+nKxSzLyWZj5HPuI9n+jUjZcDj9hEAeGUe4Pn+fqoB3x2x7bXkeX7nc1zkRZiEEOnhwzwN7q3lTrGvF6XrKUkA3t/fj1NOOSXmtdbWVgwMDKiy/Jtuugk33HBDwut2ux0mk0mVdaSCEAKHwwEASZ/Ov316Bbx+I3zuMfjchdmGKjMwPCH+P+hzwG6fUnX5hBDotIDHJ2DA7gEACIFJ2O0+VdejNpmOTbboNWIDh75BB+z2IHr7xW6BBl0Ydrs97+VPeyIPwfYxH/b2jQIATPrEfaP2cWGoAz0uej7aLt3vdcBuL9DANUsghEDDi+Nn38AQ9FrxnKf1Ix7XGOyh9JPTM/2aEUJiQDw87k4YL0YcYmCq1ZC8x1mNICYG+obFsduoz2+ZeR0XOl6O+2C32zHmEPdByD8Ju92f8zYxin+90KRvJkoSgHNc4pMrISRlEWa2XHfddbj66qulv71eL+rq6mCz2YoSgAOAzWYr2cDY3OBDT78TADCvqwkmg/pKo7oqB4bGAhgYFQfDjrYG2GxG1dejJmofm9YmDoAHQWKEzWaDZt8EAAcaakyw2Wx5L3+6Y7aGAYzB4SKA1gLAgca6ioR9Uw7XDCMRelw65xgBuAAA7XMaYKs3lHCrZgbV1nGMOUMwVNSisUaPcJjAF7CD44COtqaMXYVn+jXT1jIJYBKBsDZhvPAJPgCjMBt1eY+z4hg1DhqO1FgNeS0zn+NiqRTHS6dLQGNjI4LhSQBAW2s9bLaKnLeJUfzrpawD8La2toRCyr6+Phx55JGqLF+n00GnS9RYcxxXlJ1P11OqgZG6Txh0HCqMhdGP1VdrMTQWiNodThNtr5rHhjaacUyFwHEcJj1RPfx02BeFxlKhgUHHwesXMDgqzhbUWHVJ902prxlGcjiOi2kaZq1g57YaVFu1Um2ErZaDxy+OHRVGHhqNsoTJTL5mqAbc5Q4n/D5/pADToIIG3FKhQYWRh8cnSH/nu8xcj4vZpIFRz8MXEOD1RyUoleyaU4ViXi9K11GSIswTTzwRjz32GNxucSpz586d2LhxI0488UQAwObNm3HNNdeUYtNmBPSGWUi7t3i3ldlYeEiLMMcnaREm8wCXIw/edvYXrjMro7DUyoowzQV6oJ9tSIWYkQJuqQsmK3IFEB1DJ5MUYUoWhCrM7HIcJ7WkB0pbACt2w4zowJ1BVpQ7CyhJAH755ZejoaEBa9aswWWXXYajjz4aX/3qV6UM+KeffopbbrlF+vzExASuueYa/OhHPwIA3H333bjmmmuwefPmUmx+2VOMAJxmf4HZa7tXY41ttc5cUBKhD2q7+iOdWVkAPu2or9LBWqFBc50emhI5RMw0qIUpLdwutQVeuWFN4wPuVckDnEILMYHSPwDR8XLEEWTnxCygJHdDk8mEDRs24PHHH0d/fz/OOOMMfO5zn5PeX7ZsGW6++Wbpb57nUV1dDQAxryeTmTCA+W0m8Bwwr61wevc62bT0bA04ozaEYiEPy4AnEt+OnnXBnH7odTz++IMFJbNnm4nQDDi1MHV5WBdMOWaTBhwHuL0CwmES8+AntaHXqROAN9bKJVYlDsAj42XfkB+EiI44mgz1AIzpS8nuhnq9Hl/60peSvrd48WIsXrxY+ruqqopJUrKgvcmIB29eUhAPcEq9bFq6kOspZ0RPazHwDocJJl0sAx5PvFSJZcCnJ011+swfYigmvhumm3UajUHDc7BUaDDlDmPKE44ZN0YiFrtWlcZZW5lIUIDoeLl3UJwxLPX2MArL7NMNzBJqK3UFfXKWd/KcrQGnRsOhyqwFIWJTDalohmXAJeQzJQALwBkMQN4NUxwzXCwAT6AyEnxOeWJlKB/3iI48B841q7KeGAlKyQNw8bygAXipM/KMwsICcEZO1MUE4LM3qJJkKDFdQdmgSZHPlABAFds3DEZCEaZUcMcCcAmpEFPWjl4QCDb3iOYNy+arE4DTdvRA6fd/fUIGfPbeW2cDLABn5EQ9y4ADiBZTTUwFZUWYbNCkyDPgRj0Pk2H2nisMBiW+CNPNCu4SiBZiRgPwPft9mPKEYavVoVklP/qy0oBH7qtTbtaGfjbAAnBGTphNPAw6UeIymwNOmgEfngjC4xOg4cXCGYaI3EOayU8YDJEqKkGJd0FhGXAJGnxOyZxQPtohyk+WLbCoth55MqnUEqDauJqZUm8Po7CwSIGRExzHSYPFbM6A06Cyd0hsFWw1s6YJcuoqWQDOYMRTHS9BYRnwBJJJUKQAfL56Abhex0tZcJpQKRV1cZI9lgGf2bA7IiNn6qp0GBwNzFoXFACoiQSY+yKavUo2YMZg0POwmkU3A6b/ZjBEzCYeWo3YJdYfECQNOJs9i0ITO7QIUxAItuwU9d/LVcyAA8C157djeCIY09+iFFQYYztzsgB8ZsOudkbOrFpsgdHAY0FHRak3pWTURjIm+4YiATgLMhOgU7w1LAPOYAAQZxDpA6nDFWIa8CTEZ8B3D0T132rbYi6dZ8Gxh9SousxckRscsPNhZsMCcEbOnHdiEx7/9YGY06hOMcx0hAaVw+OiN+1s1sOnohidWRmM6Ua1rBCT+YAnEl+ESe0H1dR/lyPyAJxlwGc2LABn5MVs744XrxmczXr4VNAbSrWVda5lMChyHbjLG+mEyQIuifgizELov8sRuQ6cnQ8zG5aSYjDyoCYuqGQZ8EROOqIWk+4QjlpeVepNYTDKhmgznhDzAU+CXIJSSP13ucEy4LMHFi0wGHkQL6tgGfBElnSZ8dPLukq9GQxGWVEt9RAIwe2jRZhs/KBEizDDkv67qU6vuv673JBbt7JGPDMbJkFhMPJAq+Figm6WAWcwGEqg7lGDowEQApgMPDSzXNInh46lU+6QTH6iTvfLcqZWJmtkGfCZDQvAGYw8kevAWQacwWAogWrAB4bFHgJMfhJLhZEHzwFun4APPpsCMPMLMIHY7sFMAz6zYQE4g5Ench04y4AzGAwlUAlK/0gkAGfBVgw8z0n7ZNP22VGACURtW00GftabHMx0WLTAYOSJfMqQ+YAzGAwl0Az4yIRoYcosCBOpNGsx6Q4jGCKzQv8NALY6PVYstKC1Yfba+84WWADOYORJrASFXVIMBiMzVZEMOCHi30yCkohVJumbDfpvANDwHH59xdxSbwajCDAJCoORJ/IOj0wDzmAwlBDvoGQ2sdtxPPLxdDbovxmzC3bFMxh5UlMZ1ezptOySYjAYmTEbYzW+TAOeSKXMhm/5LNB/M2YXLFpgMPKEZsBZ9pvBYCiF47iYLDiToCRCa2qa6/SwzQL9N2N2wQJwBiNPmuvFG0NjLbtBMBgM5VTLirZZAJ4I9Uo/aJbovxmzC1YxxmDkSXuTET+9rBMdTcZSbwqDwZhG0AATAMxMgpLACWtqMTgawLknNJZ6UxgM1WEBOIOhAocfVFXqTWAwGNMMJkFJT12VDt//alupN4PBKAhMgsJgMBgMRgmQB+DMB5zBmF2wAJzBYDAYjBIgl6CwDDiDMbtgATiDwWAwGCUgRoLCNOAMxqyiZAH4hx9+iLPPPhtr167FZZddhv3796v6eQaDwWAwyplqlgFnMGYtJQnAd+3ahaOPPhrt7e24/vrrMTw8jHXr1sHn86nyeQaDwWAwyp1YDTibkGYwZhMlcUH57W9/i+XLl+OXv/wlAOCoo46CzWbDww8/jK9+9at5f57BYDAYjHKHZsANOo510WUwZhklCcA3btyIE044QfrbYDDg8MMPx8aNG5MG1Nl+PhgMIhQKSX97vV4AACEEhBA1f0oCdB2FXg8je9ixKU/YcSlP2HEpPPXVWjRU69DcoM9qP7NjU56w41KeFPu4KF1PSQLwsbEx1NfXx7xWX1+PsbExVT5/00034YYbbkh43W63w2Qy5bjVyiCEwOFwABBbDTPKB3ZsyhN2XMoTdlyKwy8vr4FGI96flMKOTXnCjkt5UuzjQpO+mShJAG4wGOB2u2Nec7vdqKysVOXz1113Ha6++mrpb6/Xi7q6OthstqIE4ABgs9nYBVhmsGNTnrDjUp6w41K+sGNTnrDjUp4U+7iUdQC+aNEibNu2Lea1zz77DF/72tdU+bxOp4NOp0t4neO4oux8uh52AZYf7NiUJ+y4lCfsuJQv7NiUJ+y4lCfFPC5K11GSqo9zzjkHjz76KLZv3w4AeOKJJ7Bjxw6ceeaZAIDnn38eBx98sOLPMxgMBoPBYDAY04WSZMDPPPNMvPXWW1i+fDlaW1tht9tx9913Y968eQCA8fFxfPDBB4o/z2AwGAwGg8FgTBc4UsJy3dHRUQwODqK7uxtms1l6fWJiArt27YrJgqf7fCa8Xi8qKirg8XiKogG32+1MA1aGsGNTnrDjUp6w41K+sGNTnrDjUp4U+7gojTlLkgGn1NfXJ7ibAEBNTU1C8J3u85mgzxhKhfH5QAiB1+uF1+tlF2CZwY5NecKOS3nCjkv5wo5NecKOS3lS7OMit75OR0kD8GJBO2bW1dWVeEsYDAaDwWAwGDMdn8+HioqKlO+XVIJSLARBgMPhgNFoLPjTD7U8HBsbK7jchZEd7NiUJ+y4lCfsuJQv7NiUJ+y4lCfFPi6EEPh8PlRXV4PnU3udzIoMOM/zqK2tLeo6TSYTuwDLFHZsyhN2XMoTdlzKF3ZsyhN2XMqTYh6XdJlvSklsCBkMBoPBYDAYjNkKC8AZDAaDwWAwGIwiwgJwldFqtfjJT34CrXZWqHumFezYlCfsuJQn7LiUL+zYlCfsuJQn5XpcZkURJoPBYDAYDAaDUS6wDDiDwWAwGAwGg1FEWADOYDAYDAaDwWAUERaAMxgMBoPBYDAYRaS8FOkzgJ6eHmzduhVz5szBIYccUurNmbXs3r0bn3zyCVpaWrBy5cqEBkwTExPYsGEDDAYDjjjiCObZWmS2b9+OTZs2Yd26dWhqapJeD4VCeOuttzAxMYFDDz0Uzc3NJdzK2YXP58Nbb70FQRBwxBFHwGg0xrz/6aefYvv27ejq6sLy5ctLs5GzkH379mHLli2oqKjAIYccAqvVGvP+8PAwNm7cCKvVirVr10Kv15doS2cumzZtwvbt26W/zz777ITPBAIBvPnmm3C73VizZg3q6+uzep+RPcPDw3j55Zelv4888ki0trbGfMbn8+H999+H2+3GsmXLYu43lI8++gh79uzBwoULsWTJkoJvtwRhqMYNN9xArFYr+fznP0+amprIySefTAKBQKk3a1YxMjJCTjrpJDJv3jxy8sknk7a2NrJixQoyMjIifeaVV14hVVVV5IgjjiAHHXQQ6ejoIDt37izhVs8u3G43WbJkCQFAnnnmGen1sbExsmLFCjJ37lyyfv16YrFYyN/+9rcSbuns4ZVXXiFNTU1kxYoV5KSTTiIrVqwg/f390vvf+c53SHV1NTn++ONJXV0d+epXv0oEQSjhFs8OfvSjHxGz2UxOPPFEcuihh5K6ujry5ptvSu8/9thjxGq1knXr1pGFCxeSRYsWkcHBwRJu8czkvvvuI2eddRY5+uijSbKwqb+/nyxYsIAsXryYHH300cRqtZKnnnpK8fuM3Pjkk0/IWWedRc466yzC8zx59NFHY95/6KGHSHd3N1m7di057rjjiMlkIr/61a+k9wVBIF/96ldJfX09Of7440lVVRW54oorirb9LABXic2bNxOO48jbb79NCCFkeHiYNDU1kT/+8Y8l3rLZxd69e8l//vMf6W+v10uWLFlCrrrqKkKIeMF1dXWR6667Tvr7v/7rv8jJJ59cku2djXzzm98k119/fUIAfsUVV5BVq1YRn89HCCHk3nvvJRaLhUxMTJRoS2cHdrudVFdXx4xV27dvJz09PYQQMTjXarXk008/JYQQsm/fPmK1WsnDDz9cku2dLYyMjBAA5LnnnpNeu+iii8i6desIIeLYVldXR37zm98QQggJBoPk6KOPJueff34pNndW8MwzzyQNwM8991yyfv16EgqFCCGE/OpXvyKNjY3E7/crep+RPwaDISEAf+SRR8jQ0FDM3xzHkYGBAUIIIf/617+I1Wol+/btI4QQ8umnnxKtVkteffXVomwz04CrxGOPPYZly5bhsMMOAwA0NDTgzDPPxKOPPlriLZtddHR04Atf+IL0t9FoxMKFCzE6OgogOtV0+eWXAwA4jsNll12GZ599Fj6fryTbPJt46aWXsGHDBlx77bUJ7z366KO44IILYDAYAADnnnsuOI7Diy++WOzNnFXcf//9aGpqwllnnYUnn3wSb731Fjo7OzFv3jwA4nFZt24dFi9eDABob2/HSSedxMa2AhMIBACIYxqls7NTev2NN96A0+nExRdfDED0Or7kkkvYcSkygiDg8ccfx6WXXgqNRgMAuPTSSzE6OipJutK9zygcp59+Omw2m/T3smXLQAjB+Pg4AHFsO+mkk9De3g4AWLx4MdatW1e0a4gF4Cqxe/dudHd3x7zW1dWF3bt3l2iLGICoyX/++efxxS9+EYB4nPR6fYxOrKurC6FQCL29vaXazFnB5OQkLr30Utxzzz3Q6XQx79H9L7+GdDod5syZw66hAvPRRx/BaDRi9erVuOuuu3DBBRdg+fLlGBgYAMDGtlLR0tKC6667Dueffz7+/Oc/45ZbbsF9992Hm2++GYB4XBobG2GxWKTvdHV1wel0SgEGo/CMjIzA5XLFXCOVlZWoq6vD7t27M77PKB533HEHFi9eLCUTSj22sSJMlQiFQgnFLwaDAaFQqERbxBgYGMAXvvAFXH755Tj11FMBpD5O9D1G4bjiiitw1llnYeXKlQnvhcNhAGDXUAnw+/3YsmULNm3ahKVLlyIUCmH9+vX44Q9/iHvvvZeNbSWksbERExMTePzxx+FwOFBXVycVx7KxrDyg+zrVNZLpfUZx+N3vfof7778fr732mjQTUeqxjWXAVcJms2FoaCjmtaGhoZjpD0bx2LNnD4488kicccYZ+NWvfiW9brPZ4HK54Ha7pdfocWPHqnB8+OGHeOihh7Bw4UL885//xD//f3t3HBN1/cdx/AkkFxQSKVKXMwcWAVIidzUv4LpyRaFoszExhaRWC5Zz4myas43ZImKxlhPZapabk2hOZqZmCh6yWTjaIaihFblokefAayWRcff7g/ld96N+1E84PH09/uL7+Xw/33vf3e543fc+3/vU1gLgdDr5/PPPMZlMREdH6zU0DuLi4pg2bRqpqanA0FSG7OxsXC6X0a/nJfAaGxtZvXo1Bw4c4OOPP+bIkSPk5+ezYMECfD4fcXFxuN1uvF6vMaanp4cJEyYQExMzjpVfXyZPnkxYWJjfa2RwcBC3201cXNyI/TL2Kisree2112hsbCQlJcVoH+/3NgXwUWK32zl69Kjx1Z/P52Pv3r3Y7fZxruz689VXX5GZmUlhYSFvvPGGX5/VaiUyMpJPPvnEaNuzZw8pKSlMmjQp0KVeN8LDw5k/fz779u2jvr6e+vp6AI4ePUpraysw9Br68/PS2tpKT08PWVlZ41HydcPhcPDTTz/x888/G21nzpwxpmnZ7XYaGhro7+8Hhs4a7d+/X+9tY+zHH38kIiICs9lstM2YMYPz589z6dIlMjIy+O233zh8+LDRv2fPHmw227ApXjJ2TCYTDzzwgN9718GDBxkcHMRms43YL2Pr1Vdf5e2338bpdBonGS6z2+18+umnxhnv/v5+GhoaAvbeFuLz+XwBuaVrnNfrxW638/vvv7N8+XIaGhpoamrC5XL95e9Oytg4e/YsVquVpKQk40JLGPoq9+GHHwbg9ddfp7KyknXr1uHxeKioqKCurs6YpiKBERISwr59+8jOzgaGzpJnZGTw7LPPkpiYSFVVFQ6Hg3fffXecK722DQ4OkpWVRVhYGAUFBZw6dYrq6moOHjyIzWZjYGAAq9XKpEmTWLx4Mbt37+bUqVO4XC4mTpw43uVfs9xuN7NmzSI1NZW8vDw8Hg9VVVU89NBDbNu2DYDS0lI+/PBD1qxZw/fff88777zDgQMH9KF1lHV1dfHFF1/Q1tZGeXk5O3bsAGDhwoXceOONNDY2kp2dzcqVKzGbzZSXl1NYWEh5eTnAiP3y/7l06RI7d+4EoKCggBUrVmCxWLBarSQkJFBWVkZZWRkbN25k+vTpxrisrCzMZjMej4e0tDSSkpLIzc1lx44d9PX10dLSYkznGksK4KPo4sWLbN68mfb2du644w6Ki4uZOnXqeJd1Xeno6GDjxo3D2pOTk9mwYYOxvXPnTvbu3YvJZGLJkiVkZGQEskxhaDGLtWvXct999xltHR0dvPfee/T19ZGZmckzzzxjzNeTsdPf309NTQ0ul4vbb7+dgoIC40IlAI/Hw6ZNm+js7CQ+Pp6SkhJiY2PHseLrw7lz59i6dSunT58mIiICm81GXl4eN9wwdPmWz+dj+/btHDp0iKioKAoLC0lPTx/nqq89TqeT6urqYe01NTVER0cDcOzYMbZt28avv/7K3Llzyc/P91sAbqR++fcuXrxIUVHRsPbnnnuOuXPnUl5ebkyl+7OXX36ZtLQ0YOiD7qZNm+jq6uKee+6hpKTEeE7HmgK4iIiIiEgAaQ64iIiIiEgAKYCLiIiIiASQAriIiIiISAApgIuIiIiIBJACuIiIiIhIACmAi4iIiIgEkAK4iIiIiEgAKYCLiMgVa25u9lt99n9ZtGgRZ86cGeOKRESuXgrgIiLXkNzcXJqbmwN+u2vWrOHxxx//R/s6HA5eeeWVMa5IROTqpZUwRUSCVE5ODuvXr2fOnDlGW3t7O9OmTQvYcsoALS0t5Obm8sMPPxAWFjbi/hcuXMBsNnP69GmmTp0agApFRK4uOgMuIhKk2tra8Hg8fm2pqakBDd8AtbW15OTk/KPwDXDLLbdgs9n46KOPxrgyEZGrkwK4iEgQeuGFFzh37hwrVqzAYrGwevVqYPgUlOzsbOrq6iguLsZut/P888/T29vLrl27yMnJ4dFHH6Wurs7v2F6vl82bN7NgwQIee+wxKisr+eOPP/62lubmZiwWi1/b7t27WbhwIQ6Hg3Xr1vHLL7/49VutVo4cOXKlD4OISFBSABcRCUKrVq0iJiaGl156iS1bthgXQB4/fpwLFy4Y+7lcLkpLS5kzZw4bNmzg2LFjPPjgg7z//vusWrWKvLw8li5dysmTJ40xy5cvZ+vWrRQVFVFaWsquXbsoKSn521q+++47zGazsd3e3s7ixYuZP38+ZWVlxMTEsHbtWr8xZrOZs2fPjtKjISISXG4Y7wJEROTfS0xMZMKECdx1113Dzj7/t/Xr17Ns2TIAVq5cyYsvvsiXX35JREQEAB988AFOp5Pk5GQ6OzvZvn073d3d3HbbbQAkJydz55138uabbzJx4sRhxx8YGCA8PNzY7unpYfLkySxbtozw8HAyMzMZGBjwG2MymYa1iYhcLxTARUSucQkJCcbf0dHRmM1mI3xfbrs8l/zEiROEhoYyb948v2P4fD6++eYb0tLShh1/ypQp9Pb2GtuPPPIIixYtYtasWVgsFux2O0uWLPEb09vbS2xs7KjcPxGRYKMALiISpEJCQkb9mLfeeismk4ktW7YM67v77rv/cszs2bM5ceKEsR0aGkpVVRVer5eTJ09SVVVFTU0NLS0txj7Hjx8nPT191OsXEQkGmgMuIhKkYmJicLvdo3rM+++/n9jYWJxOJ+np6VgsFhITE9m/fz833XTTX47Jycnh8OHDxvahQ4f47LPPCA0NZebMmTz55JN0dHTg9XqBobPpTU1NPPHEE6Nau4hIsFAAFxEJUkVFRRQXF5OWlmb8CsqVioyMpL6+ntraWuLi4khKSiI+Pv5vwzfAU089RWdnJ99++y0AM2bM4K233mLKlCmkpKSwdOlSKioqCA0d+pfT1NREZGQkDodjVGoWEQk2WohHRCSInT9/nu7ubqKiokhISBi2EE9bWxvx8fFERUUBQ4vgdHd3M3PmTOMYX3/9NTfffLNx0eVlbrebvr4+EhISRvyN74qKCrq6uqiurvarze12M336dL855/PmzePpp58mPz//iu+/iEgwUgAXEZErNjAwQGdnJ/fee++I+7a2tjJ79uwxmcMuIhIMFMBFRERERAJIc8BFRERERAJIAVxEREREJIAUwEVEREREAkgBXEREREQkgBTARUREREQCSAFcRERERCSAFMBFRERERAJIAVxEREREJIAUwEVEREREAkgBXEREREQkgP4DAdC1C21T+6oAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Audio\n", + "\n", + "rng = np.random.default_rng(1978)\n", + "lengths = [4.45, 4.775, 5.325, 5.975, 6.55, 7.175, 7.725] # the \"2/1\" ratios, scaled down\n", + "midis = [57, 60, 62, 64, 65, 69, 72] # a soft modal cluster on A\n", + "b = tap.Airport(sr, 8.0, smooth_ms=0, lengths=lengths,\n", + " pans=[-0.8, 0.8, -0.45, 0.45, -0.15, 0.15, 0.0],\n", + " levels=[0.5] * 7, darkens=[20000, 20000, 4000, 20000, 4000, 20000, 20000])\n", + "\n", + "for i, (L, midi) in enumerate(zip(lengths, midis)):\n", + " f = 440.0 * 2 ** ((midi - 69) / 12)\n", + " n = int(0.55 * L * sr) # each phrase fills about half its loop\n", + " t = np.arange(n) / sr\n", + " env = np.sin(np.pi * np.minimum(t / (0.4 * L), 1.0)) ** 2\n", + " phrase = env * (0.5 * np.sin(2 * np.pi * f * t)\n", + " + 0.25 * np.sin(2 * np.pi * 2 * f * t + rng.uniform(0, 2 * np.pi))\n", + " + 0.12 * np.sin(2 * np.pi * 3 * f * t + rng.uniform(0, 2 * np.pi)))\n", + " punch(b, i, phrase)\n", + "\n", + "yl, yr = b.process(np.zeros(int(120.0 * sr)))\n", + "\n", + "win = int(1.0 * sr)\n", + "frames = (yl + yr)[: (yl.size // win) * win].reshape(-1, win)\n", + "fig, ax = plt.subplots(figsize=(9, 2.4))\n", + "ax.plot(np.arange(frames.shape[0]) + 0.5, np.sqrt((frames ** 2).mean(axis=1)), color=C[0])\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"RMS\")\n", + "ax.set_title(\"two minutes of the terminal: coincidences come and go, nothing repeats\")\n", + "plt.show()\n", + "\n", + "# Preview: first 30 s, embedded at 16 kHz to keep the executed notebook small (the phrases\n", + "# live below 2 kHz); tools/render writes the full-rate, full-length WAVs.\n", + "mix = np.vstack([yl[: int(30 * sr) : 3], yr[: int(30 * sr) : 3]])\n", + "Audio(np.clip(mix / max(1e-9, np.abs(mix).max()) * 0.9, -1, 1), rate=int(sr / 3))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/discreet.ipynb b/notebooks/discreet.ipynb index 3fcb3a7..28b9ba0 100644 --- a/notebooks/discreet.ipynb +++ b/notebooks/discreet.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "d2d5bb06", + "id": "9f27f5d9", "metadata": {}, "source": [ "# tap.discreet~ — the loop, measured\n", @@ -23,13 +23,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "23b3fce3", + "id": "b19c9825", "metadata": { "execution": { - "iopub.execute_input": "2026-08-12T01:22:17.715239Z", - "iopub.status.busy": "2026-08-12T01:22:17.714981Z", - "iopub.status.idle": "2026-08-12T01:22:18.285043Z", - "shell.execute_reply": "2026-08-12T01:22:18.283483Z" + "iopub.execute_input": "2026-08-12T01:29:41.566251Z", + "iopub.status.busy": "2026-08-12T01:29:41.566021Z", + "iopub.status.idle": "2026-08-12T01:29:41.922596Z", + "shell.execute_reply": "2026-08-12T01:29:41.921161Z" } }, "outputs": [], @@ -58,7 +58,7 @@ }, { "cell_type": "markdown", - "id": "2d7cba52", + "id": "0aa23863", "metadata": {}, "source": [ "## 1 · The echo grid\n", @@ -73,13 +73,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "935d605c", + "id": "96dbe5ae", "metadata": { "execution": { - "iopub.execute_input": "2026-08-12T01:22:18.287447Z", - "iopub.status.busy": "2026-08-12T01:22:18.287171Z", - "iopub.status.idle": "2026-08-12T01:22:18.424164Z", - "shell.execute_reply": "2026-08-12T01:22:18.422824Z" + "iopub.execute_input": "2026-08-12T01:29:41.925411Z", + "iopub.status.busy": "2026-08-12T01:29:41.925120Z", + "iopub.status.idle": "2026-08-12T01:29:42.068944Z", + "shell.execute_reply": "2026-08-12T01:29:42.067797Z" } }, "outputs": [ @@ -128,7 +128,7 @@ }, { "cell_type": "markdown", - "id": "bb0aabb1", + "id": "660f24f4", "metadata": {}, "source": [ "## 2 · Wear as the stabilizer\n", @@ -144,13 +144,13 @@ { "cell_type": "code", "execution_count": 3, - "id": "a49b1fbd", + "id": "2b11459c", "metadata": { "execution": { - "iopub.execute_input": "2026-08-12T01:22:18.426680Z", - "iopub.status.busy": "2026-08-12T01:22:18.426479Z", - "iopub.status.idle": "2026-08-12T01:22:18.734187Z", - "shell.execute_reply": "2026-08-12T01:22:18.732875Z" + "iopub.execute_input": "2026-08-12T01:29:42.071426Z", + "iopub.status.busy": "2026-08-12T01:29:42.071211Z", + "iopub.status.idle": "2026-08-12T01:29:42.388745Z", + "shell.execute_reply": "2026-08-12T01:29:42.387440Z" } }, "outputs": [ @@ -198,7 +198,7 @@ }, { "cell_type": "markdown", - "id": "2d439156", + "id": "17620a7f", "metadata": {}, "source": [ "## 3 · Per-pass darkening, against the analytic wear transfer\n", @@ -213,13 +213,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "0c417042", + "id": "0ee0114f", "metadata": { "execution": { - "iopub.execute_input": "2026-08-12T01:22:18.737298Z", - "iopub.status.busy": "2026-08-12T01:22:18.737011Z", - "iopub.status.idle": "2026-08-12T01:22:18.949787Z", - "shell.execute_reply": "2026-08-12T01:22:18.948553Z" + "iopub.execute_input": "2026-08-12T01:29:42.390993Z", + "iopub.status.busy": "2026-08-12T01:29:42.390705Z", + "iopub.status.idle": "2026-08-12T01:29:42.596417Z", + "shell.execute_reply": "2026-08-12T01:29:42.595184Z" } }, "outputs": [ @@ -285,7 +285,7 @@ }, { "cell_type": "markdown", - "id": "ba6ec3e4", + "id": "3b58f16a", "metadata": {}, "source": [ "## 4 · The transport, in cents\n", @@ -301,13 +301,13 @@ { "cell_type": "code", "execution_count": 5, - "id": "4322f097", + "id": "c7c15082", "metadata": { "execution": { - "iopub.execute_input": "2026-08-12T01:22:18.952920Z", - "iopub.status.busy": "2026-08-12T01:22:18.952677Z", - "iopub.status.idle": "2026-08-12T01:22:19.522257Z", - "shell.execute_reply": "2026-08-12T01:22:19.521071Z" + "iopub.execute_input": "2026-08-12T01:29:42.598751Z", + "iopub.status.busy": "2026-08-12T01:29:42.598525Z", + "iopub.status.idle": "2026-08-12T01:29:43.160711Z", + "shell.execute_reply": "2026-08-12T01:29:43.159336Z" } }, "outputs": [ @@ -357,7 +357,7 @@ }, { "cell_type": "markdown", - "id": "6b11cace", + "id": "2763c554", "metadata": {}, "source": [ "## 5 · The performance move\n", @@ -371,13 +371,13 @@ { "cell_type": "code", "execution_count": 6, - "id": "d1a7aa31", + "id": "43061af5", "metadata": { "execution": { - "iopub.execute_input": "2026-08-12T01:22:19.524914Z", - "iopub.status.busy": "2026-08-12T01:22:19.524675Z", - "iopub.status.idle": "2026-08-12T01:22:20.097566Z", - "shell.execute_reply": "2026-08-12T01:22:20.095601Z" + "iopub.execute_input": "2026-08-12T01:29:43.163070Z", + "iopub.status.busy": "2026-08-12T01:29:43.162837Z", + "iopub.status.idle": "2026-08-12T01:29:43.536556Z", + "shell.execute_reply": "2026-08-12T01:29:43.533842Z" } }, "outputs": [ @@ -396,7 +396,7 @@ "text/html": [ "\n", " \n", " " @@ -441,7 +441,9 @@ "ax.legend()\n", "plt.show()\n", "\n", - "Audio(np.clip(y, -1, 1), rate=int(sr))" + "# Preview embedded at 16 kHz to keep the executed notebook small (the material lives well\n", + "# below 2 kHz); tools/render writes the full-rate WAVs.\n", + "Audio(np.clip(y[::3], -1, 1), rate=int(sr / 3))" ] } ], diff --git a/notebooks/taptools_py.py b/notebooks/taptools_py.py index be4971b..1cc841e 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -15,7 +15,8 @@ tap.overdrive~ (`Overdrive`), the step-sequencer rows behind tap.808.seq~ / tap.303.seq~ (`TriggerRow`, `NoteRow`), tap.808.kick~ (`Kick`), tap.delay~ (`Delay`), tap.multitap~ (`Multitap`), the Discreet Music -two-machine tape loop tap.discreet~ (`Discreet`), and tap.tune~'s pitch +two-machine tape loop tap.discreet~ (`Discreet`), the Music for Airports +incommensurate loop bank tap.airport~ (`Airport`), and tap.tune~'s pitch corrector (`Tune`, with the shared DspTap detector passed through as `Yin` for the notebooks' pitch tracking). Parameter names on the kernel classes mirror each kernel header's param_index enum. @@ -277,6 +278,20 @@ def load() -> ctypes.CDLL: "taptools_discreet_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), "taptools_discreet_clear": ([vp], ctypes.c_int), "taptools_discreet_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_airport_create": ([], vp), + "taptools_airport_destroy": ([vp], None), + "taptools_airport_prepare": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_airport_set_loops": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_airport_set_length_seconds": ([vp, ctypes.c_int, ctypes.c_double], ctypes.c_int), + "taptools_airport_record": ([vp, ctypes.c_int, ctypes.c_int], ctypes.c_int), + "taptools_airport_set_level": ([vp, ctypes.c_int, ctypes.c_double], ctypes.c_int), + "taptools_airport_set_pan": ([vp, ctypes.c_int, ctypes.c_double], ctypes.c_int), + "taptools_airport_set_darken_hz": ([vp, ctypes.c_int, ctypes.c_double], ctypes.c_int), + "taptools_airport_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_airport_clear": ([vp], ctypes.c_int), + "taptools_airport_phase": ([vp, ctypes.c_int], ctypes.c_double), + "taptools_airport_composite_period_seconds": ([vp], ctypes.c_double), + "taptools_airport_process": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), "taptools_yin_create": ([ctypes.c_int, ctypes.c_int, ctypes.c_int], vp), "taptools_yin_destroy": ([vp], None), "taptools_yin_frame_size": ([vp], ctypes.c_int), @@ -1138,6 +1153,78 @@ def __del__(self): self._h = None +class Airport: + """tap.airport~'s kernel (tap::tools::airport::loop_bank): up to eight + free-running tape loops of unequal, incommensurate lengths, each with a + single head that both plays and records. No setter ever resets a phase — + the free-run is the piece. Per-loop level / equal-power pan / darken; + stereo sum, no dry path.""" + + def __init__(self, sr: float = 48000.0, max_loop_seconds: float = 30.0, **params): + self._h = _LIB.taptools_airport_create() + _check(_LIB.taptools_airport_prepare(self._h, float(sr), float(max_loop_seconds)), + "prepare") + self.set(**params) + + def set(self, *, loops=None, lengths=None, levels=None, pans=None, darkens=None, + smooth_ms=None) -> "Airport": + """`lengths`/`levels`/`pans`/`darkens` are per-loop sequences (loop i + gets element i).""" + # configuration first, so ramped targets in the same call honor the new slew + if smooth_ms is not None: + _check(_LIB.taptools_airport_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + if lengths is not None: + for i, s in enumerate(lengths): + _check(_LIB.taptools_airport_set_length_seconds(self._h, i, float(s)), "length") + if loops is None: + loops = len(list(lengths)) + if loops is not None: + _check(_LIB.taptools_airport_set_loops(self._h, int(loops)), "loops") + if levels is not None: + for i, v in enumerate(levels): + _check(_LIB.taptools_airport_set_level(self._h, i, float(v)), "level") + if pans is not None: + for i, p in enumerate(pans): + _check(_LIB.taptools_airport_set_pan(self._h, i, float(p)), "pan") + if darkens is not None: + for i, hz in enumerate(darkens): + _check(_LIB.taptools_airport_set_darken_hz(self._h, i, float(hz)), "darken") + return self + + def record(self, loop: int, on: bool) -> "Airport": + """Punch the process() input onto this loop's tape (True) or freeze it + bit-exactly (False). Recording starts wherever the head happens to be.""" + _check(_LIB.taptools_airport_record(self._h, int(loop), 1 if on else 0), "record") + return self + + def phase(self, loop: int) -> float: + """This loop's head position as a fraction of its length, 0..1.""" + return float(_LIB.taptools_airport_phase(self._h, int(loop))) + + @property + def composite_period_seconds(self) -> float: + """lcm of the active loop lengths (seconds); inf once it overflows.""" + return float(_LIB.taptools_airport_composite_period_seconds(self._h)) + + def process(self, x): + x = _f64(x) + out_l = np.zeros_like(x) + out_r = np.zeros_like(x) + _check(_LIB.taptools_airport_process(self._h, _p64(x), _p64(out_l), _p64(out_r), x.size), + "process") + return out_l, out_r + + def clear(self) -> None: + """Erase every tape and rewind every head; parameters are untouched.""" + _check(_LIB.taptools_airport_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_airport_destroy(h) + self._h = None + + class Yin: """The shared DspTap pitch detector (tap::dsp::yin), passed through the C ABI so the notebooks can track pitch with the same detector the corrector uses.""" diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index 51b93cd..adc1edf 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -7,6 +7,7 @@ // The DSP cores are the same headers the Max externals compile — no Max/Min dependency. #include +#include #include #include #include @@ -1138,4 +1139,76 @@ int taptools_discreet_process(taptools_discreet h, const double* in, double* out return with(h, [&](discreet_machine& m) { m.process(in, out, static_cast(n)); }); } +// ---- tap.airport~ -------------------------------------------------------------------------------- + +using airport_bank = tap::tools::airport::loop_bank; + +taptools_airport taptools_airport_create(void) { + return static_cast(new airport_bank()); +} + +void taptools_airport_destroy(taptools_airport h) { + delete static_cast(h); +} + +int taptools_airport_prepare(taptools_airport h, double sr, double max_loop_seconds) { + if (max_loop_seconds <= 0.0) { + return -1; + } + return with(h, [&](airport_bank& b) { b.prepare(sr, max_loop_seconds); }); +} + +int taptools_airport_set_loops(taptools_airport h, int count) { + return with(h, [&](airport_bank& b) { b.set_loops(count); }); +} + +int taptools_airport_set_length_seconds(taptools_airport h, int loop, double s) { + return with(h, [&](airport_bank& b) { b.set_length_seconds(loop, s); }); +} + +int taptools_airport_record(taptools_airport h, int loop, int on) { + return with(h, [&](airport_bank& b) { b.record(loop, on != 0); }); +} + +int taptools_airport_set_level(taptools_airport h, int loop, double lin) { + return with(h, [&](airport_bank& b) { b.set_level(loop, lin); }); +} + +int taptools_airport_set_pan(taptools_airport h, int loop, double pan) { + return with(h, [&](airport_bank& b) { b.set_pan(loop, pan); }); +} + +int taptools_airport_set_darken_hz(taptools_airport h, int loop, double hz) { + return with(h, [&](airport_bank& b) { b.set_darken_hz(loop, hz); }); +} + +int taptools_airport_set_smooth_ms(taptools_airport h, double ms) { + return with(h, [&](airport_bank& b) { b.set_smooth_ms(ms); }); +} + +int taptools_airport_clear(taptools_airport h) { + return with(h, [&](airport_bank& b) { b.clear(); }); +} + +double taptools_airport_phase(taptools_airport h, int loop) { + if (!h) { + return -1.0; + } + return static_cast(h)->phase(loop); +} + +double taptools_airport_composite_period_seconds(taptools_airport h) { + if (!h) { + return -1.0; + } + return static_cast(h)->composite_period_seconds(); +} + +int taptools_airport_process(taptools_airport h, const double* in, double* outL, double* outR, int n) { + if (!in || !outL || !outR || n < 0) { + return -1; + } + return with(h, [&](airport_bank& b) { b.process(in, outL, outR, static_cast(n)); }); +} + } // extern "C" diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index 5e47b34..eb72c34 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -366,6 +366,30 @@ TAPTOOLS_API int taptools_discreet_set_smooth_ms(taptools_discreet h, double ms) TAPTOOLS_API int taptools_discreet_clear(taptools_discreet h); TAPTOOLS_API int taptools_discreet_process(taptools_discreet h, const double* in, double* out, int n); +// ---- tap.airport~ (tap::tools::airport::loop_bank) ----------------------------------------------- + +typedef void* taptools_airport; + +TAPTOOLS_API taptools_airport taptools_airport_create(void); +TAPTOOLS_API void taptools_airport_destroy(taptools_airport h); +/// Buy k_max_loops (8) reels for `max_loop_seconds` at `sr`; erases tape and rewinds heads. +TAPTOOLS_API int taptools_airport_prepare(taptools_airport h, double sr, double max_loop_seconds); +TAPTOOLS_API int taptools_airport_set_loops(taptools_airport h, int count); // 0..8 active loops +/// Per-loop setters; `loop` is 0-based. A length change is a splice (head re-wraps, no rewind). +TAPTOOLS_API int taptools_airport_set_length_seconds(taptools_airport h, int loop, double s); +TAPTOOLS_API int taptools_airport_record(taptools_airport h, int loop, int on); // 1 punch, 0 freeze +TAPTOOLS_API int taptools_airport_set_level(taptools_airport h, int loop, double lin); +TAPTOOLS_API int taptools_airport_set_pan(taptools_airport h, int loop, double pan); // -1..1 equal-power +TAPTOOLS_API int taptools_airport_set_darken_hz(taptools_airport h, int loop, double hz); +TAPTOOLS_API int taptools_airport_set_smooth_ms(taptools_airport h, double ms); +TAPTOOLS_API int taptools_airport_clear(taptools_airport h); +/// This loop's head position as a fraction of its length, 0..1 (-1 on a bad handle/index). +TAPTOOLS_API double taptools_airport_phase(taptools_airport h, int loop); +/// lcm of the active loop lengths in seconds; +inf on 64-bit overflow; 0 if unprepared. +TAPTOOLS_API double taptools_airport_composite_period_seconds(taptools_airport h); +/// Process n samples; the stereo loop sum lands in outL/outR (no dry path). +TAPTOOLS_API int taptools_airport_process(taptools_airport h, const double* in, double* outL, double* outR, int n); + #ifdef __cplusplus } #endif From 30ce359e37c26efcc9e8cf52b58c9fea30bf41a4 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 12 Aug 2026 01:38:26 +0000 Subject: [PATCH 5/9] Add the generative garden: events recirculating on the Bloom principle MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit garden.h (tap.garden~) is the family's third abstraction level: discreet recirculates audio, airport phases loops, garden recirculates events. A planted note snaps to the scale at entry, sounds a two-operator FM bell (Chowning 1973, ratio 3 — harmonic, so YIN reads the fundamental), and returns at its loop position every pass, velocity times decay and brightness times soften, until it retires below the floor. The stability inversion carries up a level: per-pass decay IS the stabilizer, the population converges by construction, and a fixed sixteen-bell pool (quietest-stolen, envelopes re-aimed rather than reset) hard-bounds the audio. Left idle, a seeded gardener (tr808::white_noise, the house xorshift64* contract) plants about one scale note per pass. Recreates the published principle only — no app tables, timings, or sounds; named for Eno's gardener-not-architect metaphor. Tests pin the return grid to a sixth of a millisecond, the decay ratio per return, the strictly-purifying FM sideband, scale membership by the YIN oracle, the full seeded triad (bit-exact per seed, differing across seeds, seed-irrelevant with idling off), the idle threshold, oldest-drop at the 64-event ring, and pool/finiteness bounds under heavy stealing. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_016zgrm1MGS1eir4hCfZBJaR --- README.md | 1 + include/taptools/garden.h | 456 ++++++++++++++++++++++++++++++++++++ include/taptools/taptools.h | 1 + tests/CMakeLists.txt | 1 + tests/garden_test.cpp | 328 ++++++++++++++++++++++++++ 5 files changed, 787 insertions(+) create mode 100644 include/taptools/garden.h create mode 100644 tests/garden_test.cpp diff --git a/README.md b/README.md index cf92a72..591e121 100644 --- a/README.md +++ b/README.md @@ -78,6 +78,7 @@ header adds no nested namespace, the class) the kernel lives in. | `tape_loop.h` | *(shared)* | Tape reel, wow/flutter transport, generation-loss wear (`tap::tools::tape`) | | `discreet.h` | `tap.discreet~` | *Discreet Music* two-machine regeneration loop (`tap::tools::discreet`) | | `airport.h` | `tap.airport~` | *Music for Airports* incommensurate loop bank (`tap::tools::airport`) | +| `garden.h` | `tap.garden~` | Generative event loop on the Bloom principle (`tap::tools::garden`) | `taptools.h` is the umbrella header that pulls in every kernel above. `stft.h`, `tune.h`, `harmonizer.h` and `conv_engine.h` reach into `tap::dsp` (the pinned DspTap submodule) for the diff --git a/include/taptools/garden.h b/include/taptools/garden.h new file mode 100644 index 0000000..b30d729 --- /dev/null +++ b/include/taptools/garden.h @@ -0,0 +1,456 @@ +/// @file +/// @brief Portable generative event-loop kernel for tap.garden~ — no Max/Min dependency. +/// @details A recreation of the *principle* behind Brian Eno and Peter Chilvers' generative +/// music apps (Bloom, 2008), as described in their published interviews and in Eno's +/// "Generative Music" talk (In Motion Magazine, 1996): a touch becomes a note; the +/// note repeats on a fixed loop, a little quieter and a little purer each pass, until +/// it fades below hearing; pitches snap to a scale so anything you plant sounds +/// consonant; and left alone past an idle threshold, the system starts planting notes +/// itself. The principle only — no scale tables, timings, or sounds are copied from +/// the app, whose name (Bloom) is a live trademark of Opal Limited. The kernel is +/// named for Eno's own metaphor: the composer as gardener, not architect. +/// +/// This is the family's third abstraction level: discreet.h recirculates audio, +/// airport.h phases loops, garden.h recirculates *events*. The stability inversion +/// carries over intact, one level up: per-pass decay is the stabilizer. An event's +/// velocity is multiplied by `decay` on every recirculation and the event retires +/// below `floor`, so the live-event population converges no matter how fast you +/// plant — and a fixed bell pool (quietest-stolen) hard-bounds the audio regardless. +/// +/// The voice is a two-operator FM bell (Chowning, "The Synthesis of Complex Audio +/// Spectra by Means of Frequency Modulation", JAES 1973): carrier plus modulator at +/// the fixed harmonic ratio 3 — odd-partial, bell-ish, and harmonic, so a pitch +/// detector reads it at the fundamental — with modulation index scaled by velocity +/// and per-event brightness (velocity-to-index is standard published FM practice). +/// Each pass multiplies the event's brightness by `soften`, so a bloom does not just +/// fade: it purifies toward a sine. Amplitude rides the shared tr808 decay_env; a +/// steal re-aims the envelope without a reset, so stolen voices glide, not click. +/// +/// Randomness: the idle gardener draws from the family's seeded xorshift64* +/// (tr808::white_noise) — deterministic per seed, so renders and tests reproduce and +/// instances decorrelate by seed. This is the library's first randomized *event* +/// source (step_seq.h promises "no randomness anywhere"; this kernel is the deliberate +/// counterpoint, and the seed contract is the bridge back to reproducibility). +/// +/// Geometry: everything is fixed arrays — k_max_events events, k_voices bells — +/// so prepare(sr) allocates nothing at all and no later call ever does. +/// +/// Honest limits: +/// - Pitch is quantized AT ENTRY: changing root or scale re-pitches nothing already +/// planted, only future plants (replants pick up the new field). +/// - Event timing is the loop grid: a plant returns at its own phase point every +/// pass, exactly — there is no swing, no drift, no humanization. +/// - A full garden (k_max_events live) retires its OLDEST bloom to make room for a +/// new plant: a touch must always speak, and the oldest is the quietest. +/// - The idle gardener is statistical (about one plant per loop pass, uniformly +/// placed), not a transcription of any published piece or app behavior. +/// - Mono out; one bell timbre family. It is an instrument, not a polysynth. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include +#include +#include + +#include "swing_vca.h" // tap::tools::tr808 — decay_env (the bell's amplitude) + white_noise (the seeded gardener) + +namespace tap::tools { + namespace garden { + + constexpr double k_pi = 3.14159265358979323846; + + constexpr int k_max_events = 64; // live blooms; oldest yields when full + constexpr int k_voices = 16; // fixed bell pool; quietest-first steal + constexpr double k_fm_ratio = 3.0; // harmonic odd-partial bell (Chowning 1973) + constexpr double k_index_max = 2.0; // modulation index at velocity 1, brightness 1 + constexpr double k_gain_epsilon = 1e-4; // below this a voice is "off" (harmonizer.h idiom) + + constexpr double k_min_loop_seconds = 0.25; // beneath this it is a buzzer, not a garden + constexpr double k_max_loop_seconds = 120.0; // the loop is a counter — no tape is bought + + constexpr double k_default_loop_seconds = 8.0; + constexpr double k_default_decay = 0.85; // velocity multiplier per pass + constexpr double k_default_soften = 0.9; // brightness multiplier per pass + constexpr double k_default_floor = 0.03; // retirement threshold + constexpr double k_default_idle_seconds = 30.0; // the gardener's patience; 0 disables + constexpr double k_default_attack_s = 0.15; // soft mallet, not a hammer + constexpr double k_default_decay_s = 4.0; + constexpr double k_default_brightness = 1.0; + constexpr double k_default_smooth_ms = 20.0; // one-pole slew for the master level + + /// Build a 12-bit pitch-class mask from scale degrees — same idiom as tune.h (copied, not + /// included: tune.h reaches into tap::dsp). + constexpr unsigned make_mask(std::initializer_list degrees) { + unsigned mask = 0u; + for (const int d : degrees) { + mask |= 1u << (((d % 12) + 12) % 12); + } + return mask; + } + + enum scale_index : int { + scale_chromatic = 0, + scale_major, + scale_minor, + scale_major_pentatonic, + scale_minor_pentatonic, + k_num_scales + }; + + // Scale presets relative to the root, addressed by scale_index — public-domain scale + // theory, deliberately NOT any app's preset list. + constexpr std::array k_scale_masks = { + 0xFFFu, // chromatic + make_mask({0, 2, 4, 5, 7, 9, 11}), // major + make_mask({0, 2, 3, 5, 7, 8, 10}), // minor + make_mask({0, 2, 4, 7, 9}), // major pentatonic + make_mask({0, 3, 5, 7, 10}), // minor pentatonic + }; + + /// One two-operator FM bell: carrier + modulator at k_fm_ratio, amplitude from the shared + /// decay_env. Phases free-run so a steal re-aims without a click. + class bell { + public: + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + m_env.prepare(m_sr); + m_env.set_times(k_default_attack_s, k_default_decay_s); + } + + void set_times(double attack_s, double decay_s) { m_env.set_times(attack_s, decay_s); } + + void reset() { + m_env.reset(); + m_carrier_phase = m_mod_phase = 0.0; + } + + /// Fire at `freq_hz`, envelope target `level`, modulation index `index`. + void trigger(double freq_hz, double level, double index) { + m_carrier_inc = freq_hz / m_sr; + m_mod_inc = k_fm_ratio * freq_hz / m_sr; + m_index = index; + m_env.trigger(level); + } + + double level() const { return m_env.value(); } // the quietest-first steal key + + double process() { + m_mod_phase += m_mod_inc; + m_mod_phase -= std::floor(m_mod_phase); + m_carrier_phase += m_carrier_inc; + m_carrier_phase -= std::floor(m_carrier_phase); + const double mod = m_index * std::sin(2.0 * k_pi * m_mod_phase); + return m_env.process() * std::sin(2.0 * k_pi * m_carrier_phase + mod); + } + + private: + double m_sr{48000.0}; + double m_carrier_phase{0.0}, m_carrier_inc{0.0}; + double m_mod_phase{0.0}, m_mod_inc{0.0}; + double m_index{0.0}; + tr808::decay_env m_env; + }; + + /// The garden bed: plant notes, they bloom on the loop, fade, and retire; left alone, + /// the gardener plants for you. + class bed { + public: + // -- lifecycle ----------------------------------------------------------------------- + + /// Set the rate everywhere and start an empty garden. Allocation-free by construction + /// (fixed arrays); still not real-time-safe by the house contract. + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + for (auto& v : m_bells) { + v.prepare(m_sr); + v.set_times(m_attack_s, m_decay_s); + } + m_prepared = true; + clear(); + } + + /// Uproot everything: kill all events and voices, rewind the loop, re-seed the + /// gardener, restart the idle clock. Parameters are untouched. + void clear() { + for (auto& e : m_events) { + e.alive = false; + } + for (auto& v : m_bells) { + v.reset(); + } + m_rng.reset(); + m_pos = 0; + m_planted = 0; + m_since_note = 0; + m_level_current = m_level_target; + } + + bool prepared() const { return m_prepared; } + + // -- events -------------------------------------------------------------------------- + + /// Plant a note: MIDI pitch (semitones, fractional accepted), velocity in (0, 1]. + /// The pitch snaps to the current root/scale, the bell sounds on the next processed + /// sample, and the bloom returns at this loop position every pass until it fades + /// below the floor. Resets the gardener's idle clock. A full garden retires its + /// oldest bloom to make room. + void note(double pitch, double velocity) { + if (!m_prepared || velocity <= 0.0) { + return; + } + event& e = allocate(); + e.pitch = quantize(pitch); + e.velocity = std::min(velocity, 1.0); + e.brightness = m_brightness; + e.offset = m_pos; // process() fires it this coming sample, then every pass + e.alive = true; + e.seq = m_planted++; + m_since_note = 0; + } + + // -- parameter targets (safe while audio runs) --------------------------------------- + + /// Loop length in seconds, clamped to [k_min_loop_seconds, k_max_loop_seconds]. + /// Instant (the loop is a counter): blooms keep their positions modulo the new length. + void set_loop_seconds(double s) { + m_loop_seconds = std::clamp(s, k_min_loop_seconds, k_max_loop_seconds); + const long n = loop_samples(); + m_pos = m_pos % n; + for (auto& e : m_events) { + e.offset = e.offset % n; + } + } + + /// Velocity multiplier per pass, [0, 1]. The stabilizer: with floor f and a plant at + /// velocity v, a bloom lives ceil(log(f/v)/log(decay)) passes, always. + void set_decay(double per_pass) { m_decay = std::clamp(per_pass, 0.0, 1.0); } + + /// Brightness multiplier per pass, [0, 1]: each return is purer, collapsing to sine. + void set_soften(double per_pass) { m_soften = std::clamp(per_pass, 0.0, 1.0); } + + /// Retirement threshold, [1e-4, 1]. + void set_floor(double v) { m_floor = std::clamp(v, 1e-4, 1.0); } + + /// The bell: envelope times in SECONDS (decay_env contract) and base brightness + /// (0..1 scale on the modulation index). Applies to future blooms; ringing voices + /// keep their envelope times until retriggered. + void set_bell(double attack_s, double decay_s, double brightness) { + m_attack_s = std::max(attack_s, 1e-6); + m_decay_s = std::max(decay_s, 1e-6); + m_brightness = std::clamp(brightness, 0.0, 1.0); + for (auto& v : m_bells) { + v.set_times(m_attack_s, m_decay_s); + } + } + + /// Root pitch class, 0..11 (0 = C). A mode: instant, affects future plants only. + void set_root(int semitone) { m_root = ((semitone % 12) + 12) % 12; } + + /// Scale preset (scale_index). A mode: instant, affects future plants only. + void set_scale(int scale) { m_scale = std::clamp(scale, 0, k_num_scales - 1); } + + /// Seconds of silence before the gardener starts planting; 0 disables self-seeding + /// (and then the seed cannot matter at all — pinned by test). + void set_idle_seconds(double s) { m_idle_seconds = std::max(0.0, s); } + + /// The gardener's seed — deterministic per seed, house triad contract. Instant. + void set_seed(uint64_t seed) { m_rng.set_seed(seed); } + + /// Master linear output level, one-pole slewed over smooth_ms. + void set_level(double lin) { m_level_target = lin; } + + void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + + // -- introspection ------------------------------------------------------------------- + + int active_events() const { + int n = 0; + for (const auto& e : m_events) { + n += e.alive ? 1 : 0; + } + return n; + } + int active_voices() const { + int n = 0; + for (const auto& v : m_bells) { + n += (v.level() > k_gain_epsilon) ? 1 : 0; + } + return n; + } + double loop_seconds() const { return m_loop_seconds; } + double decay() const { return m_decay; } + double soften() const { return m_soften; } + double floor_level() const { return m_floor; } + double attack_s() const { return m_attack_s; } + double decay_s() const { return m_decay_s; } + double brightness() const { return m_brightness; } + int root() const { return m_root; } + int scale() const { return m_scale; } + double idle_seconds() const { return m_idle_seconds; } + uint64_t seed() const { return m_rng.seed(); } + double level() const { return m_level_target; } + double smooth_ms() const { return m_smooth_ms; } + double samplerate() const { return m_sr; } + + // -- audio --------------------------------------------------------------------------- + + /// A source: no input. Advance the loop one sample, fire any blooms whose position + /// this is, let the gardener plant if the garden has been idle, and sum the bells. + double process() { + if (!m_prepared) { + return 0.0; + } + for (auto& e : m_events) { + if (e.alive && e.offset == m_pos) { + fire(e); + bloom(e); + } + } + tend(); + if (++m_pos >= loop_samples()) { + m_pos = 0; + } + + double sum = 0.0; + for (auto& v : m_bells) { + sum += v.process(); + } + const double coeff = (m_smooth_ms > 0.0) ? 1.0 - std::exp(-1.0 / (m_smooth_ms * 0.001 * m_sr)) : 1.0; + m_level_current += coeff * (m_level_target - m_level_current); + return sum * m_level_current; + } + + /// Block form: the trivial loop over the scalar path. + void process(double* out, size_t n) { + for (size_t i = 0; i < n; ++i) { + out[i] = process(); + } + } + + private: + struct event { + double pitch{0.0}; // MIDI semitones, already quantized + double velocity{0.0}; // decays per pass + double brightness{0.0}; // softens per pass + long offset{0}; // position on the loop, samples + uint32_t seq{0}; // plant order; lowest live seq = oldest + bool alive{false}; + }; + + long loop_samples() const { return static_cast(m_loop_seconds * m_sr); } + + /// Snap MIDI semitones to the nearest pitch in the current root/scale — the tune.h + /// nearest-allowed search (any non-empty mask has a note within a tritone). + double quantize(double pitch) const { + const unsigned mask = k_scale_masks[static_cast(m_scale)]; + const int p = static_cast(std::lround(pitch)); + for (int off = 0; off <= 6; ++off) { + for (const int cand : {p + off, p - off}) { + const int pc = (((cand - m_root) % 12) + 12) % 12; + if ((mask & (1u << pc)) != 0u) { + return static_cast(cand); + } + } + } + return static_cast(p); // unreachable for any non-empty mask + } + + /// Find a slot for a new plant: a dead one if any, else the oldest live bloom yields. + event& allocate() { + event* oldest = &m_events[0]; + for (auto& e : m_events) { + if (!e.alive) { + return e; + } + if (e.seq < oldest->seq) { + oldest = &e; + } + } + return *oldest; + } + + /// Sound this event now on the pool: an idle voice if any, else steal the quietest. + void fire(event& e) { + bell* voice = &m_bells[0]; + for (auto& v : m_bells) { + if (v.level() <= k_gain_epsilon) { + voice = &v; + break; + } + if (v.level() < voice->level()) { + voice = &v; + } + } + const double freq = 440.0 * std::exp2((e.pitch - 69.0) / 12.0); + voice->trigger(freq, e.velocity, e.brightness * k_index_max * e.velocity); + } + + /// One pass of wear, one level up: quieter, purer, and gone below the floor. + void bloom(event& e) { + e.velocity *= m_decay; + e.brightness *= m_soften; + if (e.velocity < m_floor) { + e.alive = false; + } + } + + /// The idle gardener: after idle_seconds without a caller plant, sow about one seed + /// per loop pass, uniformly placed, on the scale, within two octaves of middle root. + void tend() { + ++m_since_note; + if (m_idle_seconds <= 0.0) { + return; // disabled: the rng is never consumed, so the seed cannot matter + } + if (static_cast(m_since_note) < m_idle_seconds * m_sr) { + return; + } + const double u = 0.5 * (m_rng.process() + 1.0); // [0, 1) + if (u * static_cast(loop_samples()) >= 1.0) { + return; // ~one plant per pass + } + const double pitch = 60.0 + std::floor(12.0 * (m_rng.process() + 1.0)); // [60, 84) + const double velocity = 0.3 + 0.2 * (m_rng.process() + 1.0); // [0.3, 0.7) + event& e = allocate(); + e.pitch = quantize(pitch); + e.velocity = velocity; + e.brightness = m_brightness; + e.offset = m_pos; + e.alive = true; + e.seq = m_planted++; + fire(e); + bloom(e); + // Deliberately does NOT reset m_since_note's gate below the threshold: once the + // gardener starts, it keeps tending until the caller plants again. + } + + double m_sr{48000.0}; + bool m_prepared{false}; + double m_loop_seconds{k_default_loop_seconds}; + double m_decay{k_default_decay}; + double m_soften{k_default_soften}; + double m_floor{k_default_floor}; + double m_attack_s{k_default_attack_s}; + double m_decay_s{k_default_decay_s}; + double m_brightness{k_default_brightness}; + int m_root{0}; + int m_scale{scale_major_pentatonic}; // anything you plant sounds consonant + double m_idle_seconds{k_default_idle_seconds}; + double m_level_target{1.0}; + double m_level_current{1.0}; + double m_smooth_ms{k_default_smooth_ms}; + + long m_pos{0}; + uint32_t m_planted{0}; + long long m_since_note{0}; + tr808::white_noise m_rng; + std::array m_events; + std::array m_bells; + }; + + } // namespace garden +} // namespace tap::tools diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index 5f3643f..13b2c37 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -14,6 +14,7 @@ #include "delay.h" #include "diode_ladder.h" #include "discreet.h" +#include "garden.h" #include "grm_comb.h" #include "grm_pitchaccum.h" #include "ladder.h" diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index bc7300e..3421e67 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -18,6 +18,7 @@ add_executable(taptools_kernel_tests delay_test.cpp diode_ladder_test.cpp discreet_test.cpp + garden_test.cpp grm_comb_test.cpp harmonizer_test.cpp nr_test.cpp diff --git a/tests/garden_test.cpp b/tests/garden_test.cpp new file mode 100644 index 0000000..9b40f08 --- /dev/null +++ b/tests/garden_test.cpp @@ -0,0 +1,328 @@ +/// @file +/// @brief Catch2 scenarios pinning the tap.garden~ kernel (garden.h). +/// @details The event-level restatement of the family's stability story, pinned the house +/// way: the return grid to the sample, per-pass decay and softening measured on the +/// output (Goertzel partials, YIN pitch for the scale contract), the population +/// bounds (event ring and voice pool), and the full seeded-RNG triad the tr808 +/// voices established — same seed bit-exact, different seed different, seed +/// irrelevant while the idle gardener is disabled. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include + +#include +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + + using tap::tools::garden::bed; + + /// A quiet, instrument-neutral bed: idle gardener off, instant level, percussive bell so + /// grid promises are sharp. Tests opt into slow bells and idling explicitly. + bed make() { + bed g; + g.prepare(k_sr); + g.set_smooth_ms(0.0); + g.set_idle_seconds(0.0); + g.set_bell(0.001, 0.02, 1.0); + g.set_scale(tap::tools::garden::scale_chromatic); + return g; + } + + size_t at(double seconds) { + return static_cast(seconds * k_sr); + } + + void render(bed& g, std::vector& y) { + for (auto& s : y) { + s = g.process(); + } + } + + double peak(const std::vector& x, size_t begin, size_t end) { + double p = 0.0; + for (size_t i = begin; i < end; ++i) { + p = std::max(p, std::abs(x[i])); + } + return p; + } + + double goertzel(const std::vector& x, double f, size_t begin, size_t end) { + const double w = 2.0 * 3.14159265358979323846 * f / k_sr; + const double coef = 2.0 * std::cos(w); + double s1 = 0.0, s2 = 0.0; + for (size_t i = begin; i < end; ++i) { + const double s = x[i] + coef * s1 - s2; + s2 = s1; + s1 = s; + } + const double n = static_cast(end - begin); + const double re = s1 - s2 * std::cos(w); + const double im = s2 * std::sin(w); + return 2.0 * std::sqrt(re * re + im * im) / n; + } + + /// YIN oracle at an offset — same detector setup as tune_test.cpp / harmonizer_test.cpp. + double measure_hz(const std::vector& x, size_t offset) { + const size_t tau_min = static_cast(k_sr / 2000.0); + const size_t tau_max = static_cast(std::ceil(k_sr / 55.0)); + tap::dsp::yin det(tau_max, tau_min, tau_max); + REQUIRE(x.size() >= offset + det.frame_size()); + const auto r = det.analyze(x.data() + offset); + REQUIRE(r.voiced()); + return k_sr / r.period; + } + + double cents(double f, double ref) { + return 1200.0 * std::log2(f / ref); + } + + double midi_hz(double pitch) { + return 440.0 * std::exp2((pitch - 69.0) / 12.0); + } + +} // namespace + +SCENARIO("a planted note blooms again every loop period") { + bed g = make(); + g.set_loop_seconds(0.5); + g.set_decay(0.9); + g.set_floor(0.001); + g.set_bell(1e-6, 0.02, 1.0); // instant attack: the envelope is at target one sample in + + g.note(81.0, 0.8); // 880 Hz: the sine leaves the threshold within a few samples + std::vector y(at(2.0), 0.0); + render(g, y); + + // The 20 ms bell is ~1e-11 by the next return, so an amplitude threshold separates the + // return from the previous tail cleanly. The onset detector is a threshold on a sine, so + // it can sit a few samples into the cycle — the grid claim is "within 8 samples", which at + // 48 kHz is a sixth of a millisecond. + const size_t loop = at(0.5); + REQUIRE(y[0] != 0.0); // the plant sounds on the next processed sample + for (size_t k = 1; k <= 3; ++k) { + const double vel = 0.8 * std::pow(0.9, static_cast(k)); + size_t onset = 0; + for (size_t i = k * loop - 1000; i < k * loop + 1000; ++i) { + if (std::abs(y[i]) > 0.05 * vel) { + onset = i; + break; + } + } + INFO("return " << k << " onset at " << onset << ", grid " << k * loop); + CHECK(onset >= k * loop); + CHECK(onset < k * loop + 8); + } +} + +SCENARIO("each return is quieter by the decay ratio and the bloom retires below the floor") { + bed g = make(); + g.set_loop_seconds(0.25); + g.set_decay(0.5); + g.set_floor(0.05); + + g.note(69.0, 0.8); + std::vector y(at(2.5), 0.0); + render(g, y); + + // Velocity walks 0.8, 0.4, 0.2, 0.1, 0.05 and then retires: five audible returns. + const size_t loop = at(0.25); + double prev = peak(y, 0, loop); + for (size_t k = 1; k <= 4; ++k) { + const double p = peak(y, k * loop, (k + 1) * loop); + const double ratio = p / prev; + INFO("return " << k << ": peak " << p << ", ratio " << ratio); + CHECK(std::abs(ratio - 0.5) < 0.075); + prev = p; + } + REQUIRE(g.active_events() == 0); // retired below the floor + REQUIRE(peak(y, 6 * loop, y.size()) < 1e-6); // and audibly gone +} + +SCENARIO("each return is purer: the fm partial fades by the soften ratio") { + bed g = make(); + g.set_loop_seconds(0.5); + g.set_decay(1.0); // hold velocity still so only brightness moves + g.set_floor(0.001); + g.set_soften(0.6); + g.set_bell(0.005, 0.06, 1.0); + + g.note(69.0, 0.8); // 440 Hz carrier; first upper FM sideband at 4f = 1760 Hz + std::vector y(at(2.5), 0.0); + render(g, y); + + const size_t loop = at(0.5); + std::vector tilt; + for (size_t k = 0; k <= 3; ++k) { + const double fund = goertzel(y, 440.0, k * loop, k * loop + at(0.2)); + const double side = goertzel(y, 1760.0, k * loop, k * loop + at(0.2)); + tilt.push_back(side / fund); + INFO("return " << k << ": sideband/fundamental = " << side / fund); + } + for (size_t k = 1; k < tilt.size(); ++k) { + CHECK(tilt[k] < tilt[k - 1]); // strictly purer every pass + } + CHECK(tilt.back() < 0.3 * tilt.front()); // and substantially so over three passes +} + +SCENARIO("every bloom lands on the scale") { + // Off-scale and fractional plants, C major pentatonic: each must sound a scale member. + const double planted[] = {61.0, 63.4, 66.0, 70.6}; + for (const double pitch : planted) { + bed g = make(); + g.set_scale(tap::tools::garden::scale_major_pentatonic); + g.set_root(0); + g.set_loop_seconds(2.0); + g.set_bell(0.01, 0.5, 0.4); // gentle index keeps the fundamental dominant for yin + + g.note(pitch, 0.8); + std::vector y(at(0.5), 0.0); + render(g, y); + + const double hz = measure_hz(y, at(0.1)); + const double midi = 69.0 + 12.0 * std::log2(hz / 440.0); + const int pc = ((static_cast(std::lround(midi)) % 12) + 12) % 12; + const bool in_scale = + (tap::tools::garden::k_scale_masks[tap::tools::garden::scale_major_pentatonic] & (1u << pc)) != 0u; + INFO("planted " << pitch << " -> sounded " << midi << " (pc " << pc << ")"); + CHECK(in_scale); + CHECK(std::abs(cents(hz, midi_hz(static_cast(std::lround(midi))))) < 20.0); + } +} + +SCENARIO( + "the seeded garden is bit-exact per seed, differs across seeds, and the seed cannot matter while idle seeding is off") { + auto render_idle = [](uint64_t seed) { + bed g = make(); + g.set_loop_seconds(0.25); + g.set_idle_seconds(0.5); + g.set_seed(seed); + std::vector y(at(3.0), 0.0); + render(g, y); + return y; + }; + + const std::vector a = render_idle(1111); + const std::vector b = render_idle(1111); + const std::vector c = render_idle(2222); + + bool same = true, differ = false; + for (size_t i = 0; i < a.size(); ++i) { + same = same && (a[i] == b[i]); + differ = differ || (a[i] != c[i]); + } + REQUIRE(same); // same seed: bit-exact + REQUIRE(differ); // different seed: a different garden + + // Idle seeding off: the rng is never consumed, so the seed cannot matter at all. + auto render_planted = [](uint64_t seed) { + bed g = make(); + g.set_seed(seed); + g.note(60.0, 0.8); + std::vector y(at(1.0), 0.0); + render(g, y); + return y; + }; + const std::vector p = render_planted(1111); + const std::vector q = render_planted(2222); + bool exact = true; + for (size_t i = 0; i < p.size(); ++i) { + exact = exact && (p[i] == q[i]); + } + REQUIRE(exact); + REQUIRE(peak(p, 0, p.size()) > 0.1); // a real render, not silence agreeing with silence +} + +SCENARIO("left alone, the garden starts playing after idle_seconds — and never when idle is disabled") { + bed g = make(); + g.set_loop_seconds(0.25); + g.set_idle_seconds(0.5); + g.set_seed(1111); + + std::vector y(at(4.0), 0.0); + render(g, y); + + // Deterministic per seed: with seed 1111 the gardener's first plant is a fixed fact. + REQUIRE(peak(y, 0, at(0.5)) == 0.0); // patient until the threshold + REQUIRE(peak(y, at(0.5), y.size()) > 0.05); + + bed quiet = make(); // idle 0: disabled + std::vector z(at(4.0), 0.0); + render(quiet, z); + REQUIRE(peak(z, 0, z.size()) == 0.0); +} + +SCENARIO("when the garden is full the oldest bloom yields to the newest") { + bed g = make(); + g.set_loop_seconds(1.0); + g.set_decay(0.99); + g.set_floor(0.001); + + // The first plant: a high, distinctive bell. + g.note(96.0, 0.8); + REQUIRE(g.active_events() == 1); + + // Fill the garden and one more: 64 quiet low plants push the first bloom out. + std::vector scratch(200, 0.0); + for (int i = 0; i < tap::tools::garden::k_max_events; ++i) { + render(g, scratch); + g.note(45.0, 0.1); + } + REQUIRE(g.active_events() == tap::tools::garden::k_max_events); + + // Render across where the first bloom would have returned: its pitch is gone. + std::vector y(at(1.2), 0.0); + render(g, y); + const double high = goertzel(y, midi_hz(96.0), at(0.95), at(1.15)); + INFO("energy at the dropped bloom's pitch: " << high); + CHECK(high < 0.01); +} + +SCENARIO("the bell pool never exceeds its size and stays finite and bounded under heavy stealing") { + bed g = make(); + g.set_loop_seconds(0.5); + g.set_decay(0.9); + g.set_floor(0.001); + g.set_bell(0.01, 1.5, 1.0); // long ringing bells force constant stealing + + // Plant twice the pool size in quick succession, then let everything recirculate. + std::vector y; + y.reserve(at(2.0)); + for (int i = 0; i < 2 * tap::tools::garden::k_voices; ++i) { + g.note(48.0 + i, 0.9); + for (int s = 0; s < 400; ++s) { + y.push_back(g.process()); + } + REQUIRE(g.active_voices() <= tap::tools::garden::k_voices); + } + while (y.size() < at(2.0)) { + y.push_back(g.process()); + } + + // The hard bound is structural: k_voices bells, each |env * sin| <= 1, level 1. + double worst = 0.0; + bool finite = true; + for (const double v : y) { + worst = std::max(worst, std::abs(v)); + finite = finite && std::isfinite(v); + } + INFO("peak under heavy stealing: " << worst); + REQUIRE(finite); + REQUIRE(worst <= static_cast(tap::tools::garden::k_voices)); + REQUIRE(g.active_voices() <= tap::tools::garden::k_voices); +} + +SCENARIO("unprepared, the garden is silent") { + bed g; + g.note(60.0, 1.0); // a safe no-op before prepare + REQUIRE(g.process() == 0.0); + REQUIRE(g.active_events() == 0); +} From c2353f5615d267011a051a4d8dbeab314d8fefa6 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 12 Aug 2026 01:41:06 +0000 Subject: [PATCH 6/9] Reach tap.garden~ from the verification layer C ABI section, ctypes bridge class (Garden), and the executed garden.ipynb: the decay-0.5 return staircase measured at 0.795, 0.399, 0.2, 0.1, 0.05 and then retirement to zero live events; the softening FM sideband fading per pass while the fundamental holds; a chromatic sweep of thirteen plants all landing on the pentatonic by the YIN oracle; the seed triad demonstrated on two gardeners; and two minutes of self-tending garden with the population breathing around its converged size (20 events, 16 bells at the end). Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_016zgrm1MGS1eir4hCfZBJaR --- notebooks/garden.ipynb | 448 +++++++++++++++++++++++++++++++++++ notebooks/taptools_py.py | 104 +++++++- tools/capi/taptools_capi.cpp | 90 +++++++ tools/capi/taptools_capi.h | 27 +++ 4 files changed, 666 insertions(+), 3 deletions(-) create mode 100644 notebooks/garden.ipynb diff --git a/notebooks/garden.ipynb b/notebooks/garden.ipynb new file mode 100644 index 0000000..3c827d2 --- /dev/null +++ b/notebooks/garden.ipynb @@ -0,0 +1,448 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "323f9358", + "metadata": {}, + "source": [ + "# tap.garden~ — the garden, measured\n", + "\n", + "The generative event loop (`taptools/garden.h`), a recreation of the *principle* behind\n", + "Eno/Chilvers' Bloom: a planted note snaps to the scale, blooms on a two-operator FM bell,\n", + "and returns every loop pass a step quieter (`decay`) and purer (`soften`) until it retires\n", + "below the `floor`; left idle, a seeded gardener plants for you. The family's stability\n", + "inversion, one level up: **per-pass decay is the stabilizer** — the event population\n", + "converges by construction, and a fixed sixteen-bell pool hard-bounds the audio. Every trace\n", + "drives the **shipping C++** through `tools/capi` via ctypes.\n", + "\n", + "Sections: **1** the return staircase · **2** softening, in partials · **3** the scale\n", + "contract, by the pitch oracle · **4** the seeded gardener · **5** an hour of garden,\n", + "in two minutes." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d1468886", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:40:36.898478Z", + "iopub.status.busy": "2026-08-12T01:40:36.898279Z", + "iopub.status.idle": "2026-08-12T01:40:37.332788Z", + "shell.execute_reply": "2026-08-12T01:40:37.331442Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import taptools_py as tap\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.2),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.3,\n", + "})\n", + "C = tap.PALETTE\n", + "sr = 48000.0\n", + "\n", + "def tone(x, f):\n", + " n = np.arange(x.size)\n", + " return 2.0 * np.abs(np.dot(x, np.exp(-2j * np.pi * f * n / sr))) / x.size" + ] + }, + { + "cell_type": "markdown", + "id": "1e0d35c8", + "metadata": {}, + "source": [ + "## 1 · The return staircase\n", + "\n", + "One note planted at velocity 0.8 into a 0.5 s loop, `decay` 0.5, `floor` 0.05: the bloom\n", + "returns at 0.8, 0.4, 0.2, 0.1, 0.05 — a measured staircase of halvings — and then retires;\n", + "`active_events` drops to zero and the garden is silent. That retirement arithmetic\n", + "(`ceil(log(floor/velocity)/log(decay))` passes, always) is the population-convergence\n", + "theorem in one plant. (Kernel scenarios: *\"a planted note blooms again every loop period\"*,\n", + "*\"each return is quieter by the decay ratio and the bloom retires below the floor\"*.)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "77aeb815", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:40:37.336263Z", + "iopub.status.busy": "2026-08-12T01:40:37.335983Z", + "iopub.status.idle": "2026-08-12T01:40:37.551063Z", + "shell.execute_reply": "2026-08-12T01:40:37.549876Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "per-return peaks: [np.float64(0.795), np.float64(0.399), np.float64(0.2), np.float64(0.1), np.float64(0.05), np.float64(0.0)]\n", + "live events after the render: 0\n" + ] + } + ], + "source": [ + "g = tap.Garden(sr, smooth_ms=0, idle_seconds=0, loop_seconds=0.5,\n", + " decay=0.5, floor=0.05, bell=(0.002, 0.05, 1.0), scale=0)\n", + "g.note(69, 0.8)\n", + "y = g.process(int(3.5 * sr))\n", + "\n", + "t = np.arange(y.size) / sr\n", + "fig, ax = plt.subplots()\n", + "ax.plot(t, y, color=C[0], lw=0.6)\n", + "for k, v in enumerate([0.8 * 0.5 ** i for i in range(5)]):\n", + " ax.plot([k * 0.5, k * 0.5 + 0.25], [v, v], color=C[3], lw=1.2)\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"output\")\n", + "ax.set_title(\"decay 0.5: returns at 0.8, 0.4, 0.2, 0.1, 0.05 — then retirement\")\n", + "plt.show()\n", + "\n", + "peaks = [np.abs(y[int(k * 0.5 * sr) : int((k + 1) * 0.5 * sr)]).max() for k in range(6)]\n", + "print(\"per-return peaks:\", [round(p, 3) for p in peaks])\n", + "print(\"live events after the render:\", g.active_events)" + ] + }, + { + "cell_type": "markdown", + "id": "b1b7fbcd", + "metadata": {}, + "source": [ + "## 2 · Softening, in partials\n", + "\n", + "With `decay` held at 1.0 (velocity still) and `soften` 0.6, only the timbre moves: the FM\n", + "bell's first upper sideband (4× the fundamental, carrier + ratio-3 modulator) fades pass by\n", + "pass while the fundamental holds — each return is *purer*, collapsing toward a sine. The\n", + "tape family's generation loss, restated in partials instead of passbands." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "58b22404", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:40:37.553851Z", + "iopub.status.busy": "2026-08-12T01:40:37.553571Z", + "iopub.status.idle": "2026-08-12T01:40:37.694273Z", + "shell.execute_reply": "2026-08-12T01:40:37.693228Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sideband/fundamental per return: [np.float64(1.252), np.float64(0.546), np.float64(0.301), np.float64(0.175)]\n" + ] + } + ], + "source": [ + "g = tap.Garden(sr, smooth_ms=0, idle_seconds=0, loop_seconds=0.5,\n", + " decay=1.0, floor=0.001, soften=0.6, bell=(0.005, 0.06, 1.0), scale=0)\n", + "g.note(69, 0.8) # 440 Hz carrier -> first upper sideband at 1760 Hz\n", + "y = g.process(int(2.5 * sr))\n", + "\n", + "loop = int(0.5 * sr)\n", + "passes = np.arange(4)\n", + "fund = [tone(y[k * loop : k * loop + int(0.2 * sr)], 440.0) for k in passes]\n", + "side = [tone(y[k * loop : k * loop + int(0.2 * sr)], 1760.0) for k in passes]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(passes, fund, \"o-\", color=C[0], label=\"fundamental (440 Hz)\")\n", + "ax.plot(passes, side, \"s-\", color=C[1], label=\"FM sideband (1760 Hz)\")\n", + "ax.set_xticks(passes)\n", + "ax.set_xlabel(\"return\"); ax.set_ylabel(\"partial level\")\n", + "ax.set_title(\"soften 0.6: the sideband fades, the fundamental holds — purer every pass\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "print(\"sideband/fundamental per return:\",\n", + " [round(s / f, 3) for s, f in zip(side, fund)])" + ] + }, + { + "cell_type": "markdown", + "id": "8144c147", + "metadata": {}, + "source": [ + "## 3 · The scale contract, by the pitch oracle\n", + "\n", + "Plant every chromatic pitch from 60 to 72 into a C major-pentatonic garden and measure what\n", + "actually sounds with the DspTap YIN detector: every bloom lands on {C, D, E, G, A}, whatever\n", + "you planted. Quantization happens at entry — the instrument makes wrong notes impossible,\n", + "which is most of why Bloom-style instruments feel effortless. (Kernel scenario: *\"every\n", + "bloom lands on the scale\"*.)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "26c3b65b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:40:37.697003Z", + "iopub.status.busy": "2026-08-12T01:40:37.696639Z", + "iopub.status.idle": "2026-08-12T01:40:38.783825Z", + "shell.execute_reply": "2026-08-12T01:40:38.782751Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "all sounded pitches on the scale: True\n" + ] + } + ], + "source": [ + "pent = {0, 2, 4, 7, 9}\n", + "planted = np.arange(60, 73)\n", + "sounded = []\n", + "for p in planted:\n", + " g = tap.Garden(sr, smooth_ms=0, idle_seconds=0, loop_seconds=2.0,\n", + " scale=3, root=0, bell=(0.01, 0.5, 0.4))\n", + " g.note(float(p), 0.8)\n", + " y = g.process(int(0.5 * sr))\n", + " periods = tap.Yin().track(y[int(0.1 * sr):], hop=512)\n", + " hz = sr / np.median(periods[periods > 0])\n", + " sounded.append(69 + 12 * np.log2(hz / 440.0))\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(planted, planted, \":\", color=\"gray\", lw=0.8, label=\"planted = sounded\")\n", + "ax.plot(planted, sounded, \"o\", color=C[0], label=\"sounded (YIN)\")\n", + "for m in range(60, 73):\n", + " if m % 12 in pent:\n", + " ax.axhline(m, color=C[2], lw=0.5, alpha=0.4)\n", + "ax.set_xlabel(\"planted MIDI pitch\"); ax.set_ylabel(\"sounded MIDI pitch\")\n", + "ax.set_title(\"C major pentatonic: every plant snaps to a scale tone (horizontal lines)\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "ok = all(round(s) % 12 in pent for s in sounded)\n", + "print(\"all sounded pitches on the scale:\", ok)" + ] + }, + { + "cell_type": "markdown", + "id": "439fe0e1", + "metadata": {}, + "source": [ + "## 4 · The seeded gardener\n", + "\n", + "Idle for half a second, then the garden plays itself: roughly one plant per loop pass,\n", + "uniformly placed, on the scale, within two octaves. The randomness rides the family's\n", + "seeded xorshift64* — same seed, bit-identical garden; different seed, different garden;\n", + "gardener disabled, the seed cannot matter at all (the rng is never consumed). The library's\n", + "first randomized event source, with the tr808 seed triad as its contract." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2a44936a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:40:38.786156Z", + "iopub.status.busy": "2026-08-12T01:40:38.785963Z", + "iopub.status.idle": "2026-08-12T01:40:39.862934Z", + "shell.execute_reply": "2026-08-12T01:40:39.861747Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "same seed bit-exact: True different seed differs: True\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuAAAAGICAYAAAAAkVWjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAOxAAADsQBlSsOGwAAt5pJREFUeJzs3Xd8FNUWB/DfbEmy6SSkAAFCDYQSuiBIC0WQIiqKgGJFHxbsoGDBjgoiKDawV1BRkKJ0UanSQy8BAiEhCenb574/ZneyNdlesuf7+bwnO5mdubm72T1z59xzOcYYAyGEEEIIIcQnJP5uACGEEEIIIaGEAnBCCCGEEEJ8iAJwQgghhBBCfIgCcEIIIYQQQnyIAnBCCCGEEEJ8iAJwQgghhBBCfIgCcEIIIYQQQnyIAnBCCCGEEEJ8iAJw4hNFRUXYsGEDlEqlv5tSb+j1emzYsAGXLl3yd1N8Sq1WY8OGDSgoKPDaORztW8v3tS9eE1/8/o46f/48NmzY4LHjXbp0CRs2bIBer691v5ycHOzatcuhY5aUlGDTpk117ufMMf3Jsp0nT57EgQMHPH4eT7+23uCv9x9x3l9//YXTp0/7uxkBhQJwL9u1axcOHz7s72b43Y4dOzB06FBcvHjR300JOlqtFhs2bEB+fr7ZdqVSiaFDh2LNmjU+Pa+7+7p7/itXrmDo0KHYvHmzx85lydG+tXxfe/I18efv76hly5Zh6NChHjvemjVrMHTo0Dov1N944w1MmzbNoWM+9thj+Pjjj+vcz5ljmsrLy8OGDRvA87xD291l2c7CwkL07dvX5Ys+e+309GvrDl+10dH3H3HeTTfdhM8//9zfzQgoFIB72bRp0/Dqq6/6uxkkiJWVlWHo0KH4448/zLbLZDJkZ2ejSZMmPj2vu/t64/ye5u2+dYQ/f//6Yt++ffj222/x4osveu0cv/76K4YOHQqNRuPQdk/r27cv+vTpg+eff96l5/uqne7wVRubNGmC7OxsyGQyr56HEACgd5kXbd++HRUVFSgoKBBvkzVp0gQSiQTFxcW49tprxX2PHj2Kixcvom/fvlAoFACEkY2DBw/iuuuuQ3h4uLjvhQsXkJubi8TERLRv3x4cxzncpsOHD6OqqgpZWVkIDw/Hxo0b0a5dO6SlpQEADh06JN7ajoiIQHp6uvgzUzt27EBsbCwyMzNRWFiIY8eOITMzEw0bNgQg3Cbft28foqOj0bFjx1rblJubiwsXLiA5ORkZGRlmP1Or1di2bRs6deqElJQUnDhxAkVFRejSpQsiIyPdPt7Jkydx4cIFDBo0SOzHS5cu4dy5c0hJSUF6ejokEueuUy3PceTIEZSVlaFr166IiIgw23fLli3Q6XQAgPj4eLRu3Rrx8fHiz1UqFf766y8AwJEjR8T3UefOnZGYmIiZM2ciMzPTrT6w1ae1nTc5OdnseI7syxjDkSNHUFJSgpYtW9YZ2NZ2TEvuvidskcvlNvvWmfe1O23wxO/vyHtdr9fj8OHDqKioQEZGBpKSkqyOr9frceLECZSWlqJNmzbi37gljUaD/fv3Q6FQoGPHjjY/l6qqqnDo0CHxd7H3elkqKCjAyZMn0apVKzRq1Mih5wDAggUL0Lt3b5t/I44es7Y2nzt3DsePHwcAbN68GXK5HBKJBK1atbK5ffDgweJzHel7R9t5zz334O6778bcuXPtvj622Gu/aTsBx17bun6f8+fP48SJExgyZIhDx/NHG7OysjBz5kzI5XKbbT5w4AAiIiLQqVMnu+0Fan/PVFRUYOfOnejRo4f4WV9aWoo9e/agRYsWaNWqlbjv5s2b0aJFC6Snp7vcf6Ys30s5OTmoqqpCr169AAgpdfv37wcASCQSNG7cGC1btkRYWJjZcRzplxMnTqC4uBidOnVCdHS03TZVVFQgJycHHMchKyvL6jty37594DgOXbp0QUlJCY4ePYqmTZuiWbNmVseqqqrCiRMnwBhDu3btHP588RtGvObuu+9mMTExLCUlhWVnZ7Ps7Gw2b9489sEHHzC5XM4qKyvFffv06cMAsJUrV4rb5syZw+Lj45ler2eMMVZSUsJuuOEGFhERwXr06MHi4+NZ+/bt2cGDB+tsS35+PuvZsyeLiopiPXv2ZO3bt2d79uxhANiiRYvMzmlsa58+fVhMTAzr378/O3/+vNnxOnTowKZMmcLeeOMN1qZNG5adnc127NjBGGNsy5YtLCUlhaWkpLCuXbuyIUOGsO+++44BYCdPnhSPcebMGda3b18WHR3NevXqxRITE1mvXr3YhQsXxH0uXLjAALAvv/yS3XbbbSwrK4s1adKEJSYmsu3bt5u1yZnjffbZZ2zcuHEsKyuLZWdnM71ez5RKJRs7diyLiopiffr0YRkZGaxDhw5m5zlw4ADbtGlTrX1teo5Ro0axrKws1qhRI9awYUP2559/mu07atQosb+7du3KwsLC2IMPPii+5pcvX2b9+/dnAFhmZqa4719//cUqKioYAPbpp596vE9rO6+luvbdvXs3a9OmDUtMTGTdu3dnYWFhbNy4cay8vNxuH9Z2TE+/J2yx1beOvK9dfU288fvX9l5njLFly5ax1NRUlpaWxnr06MEUCgV7/PHHxZ8zxtiePXtYq1atWFpaGuvbty9LTU1lt956KystLWWMMfb2228zAOzIkSOsU6dOrGfPniwyMpJdd911rKqqyux3mj9/PouKimJt27Zlbdq0YVFRUey9994z2+fTTz9lAFhFRYW47fnnn2cymYx16NCBtW7dmr3++uts0qRJrHv37rW+htXV1SwiIoLNmzfP6meOHrOuNn///fcsIyODAWCDBg1i2dnZbNiwYXa3GznS9860s6qqislkMrPPckfU1k5nXltHfh9njuevNlq+/4zH379/P8vMzGT9+vVjc+bMqbVP63rPlJWVMalUyj755BNx28cff8wAsJtuukncdu7cOQaA/fLLL271n9Fzzz0nvpfatGlj8720Y8cO8bNm4MCBLD09nSUnJ7Nly5aZHau2fikvL2fDhg1j4eHhrEePHqxVq1Zsy5YtLDExkc2aNUs8hk6nYzNmzGAKhYJ16NCBtW/fnjVo0ID9+OOPZufKzs5mw4cPZ19//TVr06YN69KlC5NKpezZZ5812+/jjz9msbGxrEOHDqxXr14sOTmZvfbaa3X2iz9RAO5l3bt3Z7fddpvZtiNHjjAAbN26dYwx4UtbJpOxJk2asMcee0zcb8CAAWzs2LHi4xtuuIGlpaWx06dPi8/r378/a9KkidkXli3jxo1jbdu2Zfn5+YwxIZifOHGiVQBuqaysjPXr14+NGjXKbHuHDh1YRkYGe+mll8y2V1ZWsuTkZHbrrbcyrVbLGGNs+/btrFu3bmaBSnV1NWvVqhXr168fKy4uFp87aNAgds0114jHMwYR3bt3FwM6tVrN+vXrZ7afs8fLyspiW7duNWv7O++8wxITE1lBQYG47fjx4+y3334TH48dO5aFh4fb7S/Tc3Tq1Ilt2bKFMcaYXq9nd9xxB0tISBCDF1tycnJYgwYN2Pvvvy9uu3LlCgPAPv/8c7N9LYM9T/epvfPaYm/f4uJilpSUxEaMGMGUSqX4OzZs2JDdeuutLh3T0+8JWyz71tH3tauviTd+/9re65s3b2YSiYS9/PLLjOd5xhhj+/fvZzExMWz+/Pnifj169GC33nqruA9jjC1fvpydPXuWMVbzRTxlyhTx9zt69CgLCwszO87y5csZAPbxxx+L2xYuXGgWYDBmHQCtXLmSATD7Up41axbLyMioMwDfsGEDA8D+/fdfs+2OHtPRNi9atIgBEN/fdW13tO+d/d27d+9u9n3hKHvtdPS1dfT3cfR4/myjvQB80qRJ4vFr4+h7plevXmzChAni49tuu401adKEJSQkiBcEn3/+OZNIJOJ53em/3377jQFgP//8s7htzpw5rG3btnX+Hb377rtMoVCYDcLV1i/Tpk1jKSkp7MSJE4wx4TNxwoQJLCYmxiwAf/bZZ1lERIT4HckYY4sXL2YymcxsUDE7O5u1adOGPfHEE+Jrt3jxYsZxHMvJyWGMMVZQUMCkUilbsmSJ+DylUun0BamvUQDuZbYCcMYYS01NZc888wxjjLHVq1ez6OhoNnfuXNa5c2fGmPDFHR4eLl45nzhxggFgCxcuNDuOcRTb9I1n6cyZMwwA++KLL8y2r1q1ymYArtPp2OnTp9nWrVvZ+vXr2fTp05lCoTD7Eu7QoQNLTU0VgxGjjz76iEkkEqvRvQcffNAsUFm6dCkDwA4dOmS23/bt2xkAtnPnTsZYTRBx7733mu331VdfMQCsqKjIpeNNmjTJqp8efvhh1rp1a6tRKFMvvPACGzFihN2fm55j8uTJZtsLCwtZWFiY1YhcdXU1y8nJYRs3bmTr169nffv2NfsidTQA93SfeiIAN375GD+MjV599VXGcZzVnRVHjunp94Qtln3r6Pva1dfEG79/be/1oUOHso4dO5r9TTPG2PTp01mLFi3Exw0bNmTPPfec3TYav4jXr19vtn3kyJFsyJAh4uNrr72WdevWzer5nTp1Yv369RMfWwZAAwcOZP379zd7jlqtZsnJyXUGDsb3nukFtTPHdLTNzgbgjva9s7/7hAkTWKtWray216Wu4Lau19bR38fR4/mzjfYC8FWrVtXaPiNH3zMzZ85kKSkp4uOUlBT2/vvvM47j2N69exljjN1xxx2sa9euTv+utgwYMIANHDjQbJtGo2Gpqak230uFhYVs9+7dbP369Wz16tUMAPv++++t2mLZL2VlZSwsLIy9/vrrZtt37NjBAIgBeGVlJVMoFOzJJ5+0One7du3Y//73P/FxdnY2i42NNcsYUKvVLCIigr3zzjuMsZo4yNYd2kBGOeB+MmjQILGKwebNm9GvXz8MGzYMM2fORFFREQ4cOAC1Wo1BgwYBEPKgAKB3795mx+nWrRvCw8Oxd+9e3HvvvTbPdeTIEQBA9+7dzbZbPgaAP//8E9OmTUN5eTnatGkDhUKBy5cvQ6lUoqSkBImJieK+Xbt2tZqscvjwYTRq1Mgqb7xXr1746KOPxMfbt28Xj3358mVxu3H2+cGDB8W8NADo0aOH2fGM+V95eXlITEx0+nim/zYaPXo0PvjgA/Tp0weTJk1CdnY2OnToYLbPnDlzrJ5nzzXXXGP2OCkpCenp6cjJyRG3vfnmm3jjjTeQlJSEtLQ0yGQynD59Gmq12uHzGHm6Tz1h3759SEhIQJs2bcy29+nTB4wx7N+/H02bNnXp2J5+T9TG0fe1JU+2wZKjr5+t42/fvh39+/fHxo0bzbZLJBKcPXsWlZWViI6OxtixY/HWW2/h3LlzGD16NLKzs23mGNtqy5YtW8TH+/btw9133231vN69e+Pbb7+1+zsePnwYU6ZMMdsWFhaGLl26oLi42O7zACGfFQAaNGjg0jFdbXNdHO17Z3/3hIQE8Xf2pLpeW0d/H0ePFwhttOTo36ij75lBgwbhzTffxJEjR8AYQ0FBAW6++WZ8+umn2Lx5M7p27YrNmzfj1ltvdfp3tSUnJ8fqvSSXy9G5c2ez99LVq1cxZcoU/Pnnn+jQoQPi4+PBcRw4jrNZwcyyX06ePAmNRoOePXuabe/evbvZXKr9+/dDqVQiOjraqoxkw4YNcfDgQbNt7du3R1RUlPg4LCwMqampyMvLAwB06NABrVq1wrhx43D33Xdj+PDhVnPnAhEF4H4yaNAgLFu2DGVlZdi0aRMmTJiArKwsJCQkYMuWLdi3bx+SkpLEiV4qlQoArD4kOI5DVFRUrWWTysvLbT7X8nFZWRluvfVWTJo0CYsWLRL/YBYvXoyHHnoIjDGz/W1NGiovL7f5QWa5raqqCoAQgFrKzs5GQkKC2TbTiYkAxD8s4+/t7PFstX3YsGHYtm0bPvnkE7z11luYPn062rdvjy+++MKlIMleP5SVlQEA1q1bh2effRa//vorxo4dK+4zZswYl0qKebpPPUGlUtnsh5iYGLfP5en3RG0cfV9b8mQbLDn6+tl6r1dXV+Po0aN226XVagEAH3/8MXr16oWffvoJ9957L5RKJW6++WZ89tlnZr+7rbaYtkOtVtt9Hxg/22ypqKiw2+91BeDGyewqlUqcVOfMMV1tc10c7Xtnf3elUin+zp5U12vr6O/j6PECoY2W7E2QteToe6Zfv36Qy+XYtGkTGGPIzMxEamoqBg8ejE2bNmH06NHIy8sTB+BMudJ/jr6XHn/8cRw6dAi5ublITU0FIPRdVFSU1fc/YN0v9mINmUxmNrnS+Lm4evVq/P3331a/T+vWrc22Wf7Oxv2Mv3dERAR27tyJ9957D2vWrMH8+fOhUCgwa9YsPPvss1bPDRQUgHuZvdnJgwcPhl6vx2+//Yb9+/fj448/BsdxGDBgADZv3ox9+/Zh4MCB4vONI2/nzp1D+/btxeOUl5ejpKSk1lHE9PR0AMLMZeO/AaGaiqn9+/ejrKwMDzzwgNnVqnEGuiO/W3p6On755Rfo9XpIpVJx+7lz58z2a9asGRhjWLt2rdmXo6ucPZ6916Vv377o27cvAKE/Jk+ejDvvvBPHjh1zuk2WvzNjDBcuXBBn72/duhWNGjUyC74BYfa46QeYozPcPd2nzlTXsbdvWloa8vPzodFozGbS5+bmAkCt71tnzm+LJ/vD0fe1J9vg7u9f23GaNm2Ka6+9Ft98802tz5VKpZg6dSqmTp0KjUaDn376CVOmTEFmZiZeeuklh9vQpEkTm32Vm5trs8qSUfPmzXH+/Hmr7XX1O1DzmXn58mXxgs+ZYzraZnuvk73tjva9s7/75cuXXbqb5O77zNHfxx3+bqOj53f0PRMZGYlrrrkGmzdvBmNMDLQHDRqEpUuXYv369ZBKpejfv79L7bVk771kGQNs3boV48aNE4NvwP73P2DdL6axhund+qKiIlRXV4uPjXfrpk+fjsmTJzv+i9QiMTERL7/8Ml5++WWUlJTgpZdewnPPPYdBgwZZZQ4ECqoD7mXx8fGorKy02t6qVSs0bdoUr776KmJjY9GtWzcAQmC+Zs0a7N692+zq99prr0ViYqJVIfulS5cCEEZN7enWrRvS0tKsPnx+/PFHs8fGWzymK+xdvXrVar/ajBkzBpWVlVixYoW4Ta/XWx1jwoQJUKvVYvtNVVZW1jkiYckTxyspKTF73KVLF4wYMcLstu7BgwcdXgBl2bJlYolBQLjav3LlivhaRUVFoaKiwmz04o8//sCZM2fMjhMbGwuJRGLzfWTK033q6Hlr23f06NHQarVWt+yXLl2Kxo0bW91OdfX8tniyPxx9X3uyDe7+/rWZOHEiVq5cafNL2fh3wPM8SktLxe1hYWGYOHEiUlNTnU51GD16NH7//XdcuXJF3Jafn481a9bU+tk1ZswY/Prrr6ioqBC3HT58WCzxVhvjhfSePXtcOqajbTaOzlm+Tva2O9L3zrTT6L///sN1110nPuZ5Hhs2bBBTEO2x105HOfr7uCMY2gg49z4fNGgQtmzZgq1bt4qDMgMGDEBVVRUWLFiA7t27IzY21iPtGjNmDH777Tez/jt27JhVqkdUVJTVCrsffvihwxcg6enp6Ny5M7766iuz7V999ZXZwEW7du3QtWtXLF682OZCVc6+JmVlZWarlyYkJOCBBx4AAK+kZXkKjYB7Wb9+/TBv3jx89dVXaNy4MZo0aSKOYA8aNAhfffUVxo4dK444Dx48GA8//LD4c6OIiAh8+OGHuP3223HXXXdhzJgxOHDgAF5//XU88cQTNvO5jcLDwzF37lxMnjwZ4eHhGDx4MHbs2CGOSBr/uLp27YoePXpg2rRpePHFF6HVavHRRx/hzjvvxNtvv+3Q79u9e3fceeeduOeee3Du3Dk0a9YMX3/9NQYOHGj2RdilSxe8/fbbePTRR3Ho0CEMHDgQOp0O+/btw7Jly7B3716nbs974ngzZsxAQUEBRowYgWbNmuHkyZP49NNPxdcDAF544QWsW7fOoVvQw4cPx5gxYzBlyhRcvnwZL774Im699VbxS3LSpEl48803MX78eNx77704deoUVqxYgTFjxogjxICQq9erVy98/vnnaNq0KaKiomzWUPZ0n9o7r2Ud8Nr2ve666zB16lRMmzYNly5dQrt27bBs2TJs2rQJK1asqHVU2N4xHeXJ/nD0fe3JNrj7+9fm+eefx7///ovevXvjiSeeQEZGBi5duiTmyC5btgx6vR5dunTBjTfeiJ49eyImJgarVq1CcXGxVT5pXV566SX88ccfGDhwIJ5++mkwxvDmm2+iadOmtY6kz5gxA99//z0GDRqExx9/HFVVVfjxxx8xatSoOkfBW7RogY4dO2Ljxo24/fbbnT6mo23u3bs3ZDIZXnrpJYwePRpyuRyDBw+2u92Rvnf2dz98+DAKCwvNgjyNRoOhQ4diypQp+OKLL+z2k712OsrR38cdwdBGwLn3+aBBg/DKK6+A4zgMHDgQgHDR3b17d+zatQszZszwSJuAmvfS4MGDMX36dFRXV2P58uW44YYbzC5Kpk6diieeeAJt27ZFp06dsGrVKqSlpTm8FgbHcXjnnXcwcuRI3HHHHbjxxhtx6NAhXLlyxSqN5Ouvv8aQIUPQt29f3HfffUhKSsKpU6fwww8/4P7778f999/v8O+3b98+PPjgg7jjjjuQmZkJlUqF999/H+3atcOAAQMcPo6vUQDuZc888wykUil++uknKJVKjBgxQgzAx48fj4sXL2LChAni/u3bt8eNN94IQLhKNDV+/Hi0bNkSS5cuxZIlS5CYmIjly5eL+9dm4sSJSE5Oxueff44vv/wSN9xwA8aOHYtXX31VTHeQSqXYsGED3nnnHSxbtgypqalYsmQJCgsLsXfvXrMUgj59+qBt27Y2z/XZZ5+hd+/eWLduHaKiovDkk08iIiIC+/btMwsan3zySQwYMABff/01vvzySzRo0ABdunTBvn37xIlTERERyM7ONrslBgBxcXHIzs5GXFycR44HAJ9++inWrl2L33//HWvWrEFKSgq+/vprjBo1StwnKyvL4dXYevXqhfHjx2Px4sUoKyvDyy+/jP/973/iz1u0aIFdu3Zh4cKF+Oyzz9C5c2f8/vvv+OSTT5CSkmJ2rO+++w7z58/HRx99BK1WixdffBE9e/a0Wq3R031q67y2AvDa9v3oo48wZMgQ/Prrr/jnn3/QsmVL7Nmzx6Fg0tYx27dv79H3hC22VsJ05H1t63mutsHd37+297pCocCGDRvw448/4o8//sDmzZvRvHlz3HbbbRg3bhwA4QLg0KFD+PLLL7F27VpUVVWhTZs22L9/v/i337x5c2RnZ1sdPyMjA/369RMfJyUlYc+ePfjwww+xYsUKcByHu+66C9OmTTN7vSxXImzYsCF2796NefPm4fvvv0fbtm3x7bff4osvvrD5e1l6+OGH8cwzz2DRokVifrSjx3S0za1atcKKFSvw3XffYd68eeA4DoMHD7a73ZG+d/Z3//rrr5GZmWkWbBgn/Xbt2rXWPrLXTkdfW0d/H0eP5882Wr7/7B3fHkffM4BwV3vo0KFIS0szuwifMmUKYmJirEbM3ek/43vpnXfewXfffYd27drh66+/xj333GOW7vjoo48iOTkZv/76Kw4dOoTRo0djypQp2LVrF5o3b15nWwBg6NCh2LZtGz766CN8+eWX6N+/P2bPno3Lly+b5XZ36NABOTk5WLp0KdauXQudToe2bdvio48+EjMCAOEOvunouWn/GWOpgQMHYu3atfjiiy/w9ddfIzw8HOPGjcN9991nln4WaDhmK7Oe1Du2Znl/8cUXuPvuu5GTk2NzpTjimry8PDRt2hTff/+92cUVIcS3VCoVMjMz8cQTT5jdyapPysvL0bJlS3z44YcYP368uP2rr77C008/jdzcXK9MziTBxTIGKCkpQZs2bXDfffdh7ty5fmxZ6KIR8BCxdetWvP/++7jllluQmJiI3bt3Y8GCBbjrrrso+CaE1EsRERFYtGiRU/NYgs3GjRtx4403mgXfgJAX+8Ybb1DwTQAI+eXjx49HZmYm8vPzsXDhQkRERGD69On+blrIohHwELJhwwb8/PPPOHfuHBo2bIgRI0ZgwoQJHqu2QARFRUWYMGECZs+eLeb2EUIIIf5y8eJFfPzxx+Ik3u7du2Pq1Kl2UwqJ91EATgghhBBCiA9RGUJCCCGEEEJ8iAJwQgghhBBCfIgCcEIIIYQQQnyo3ldBMa7mFhERQZMNCSGEEEKI1zDGoFKpEB8fX+siRvU+AC8tLUViYqK/m0EIIYQQQkJEcXFxrast1/sAPCIiAoDQEb6uh8oYQ0FBAVJSUgJq9J0xhmqdFpEyecC1KxD7K1BRfzmH+ss51F/Oof5yDvWX86jPnOOv/lIqlUhMTBTjT3vqfQBu7HSFQuGXANx43kD6Y9Ho9Xh5/3q8c80ohNlY4tVfArW/AhX1l3Oov5xD/eUc6i/nUH85j/rMOf7ur7rOWe8DcGItTCrFwmvH+rsZhBBCCCEhiaqghCCeMZwsKwJPazARQgghhPgcBeAhSM94/HT2EPSM93dTCCGEkKCnVOmh19OgFnEcBeAhSC6R4tkugyCXBE7+NyGEEBKsHp13Cmv+KfZ3M0gQoQA8BOkZj635Z2gEnBBCCPGAiio91FoaASeOowA8BDEGnK0oAaWAE0IIIZ5BX6nEGVQFJQTJJBLc1baHv5tBCCGE1AtUFdD7VBoejGdQRNSP9FkaAQ9BOp7HD6cPQMdTCgohhBBCAt+HP13C3K8v+LsZHkMBeAjiACSEK0AX7IQQQohnMMrr9Cq1lodGU38GDikFJQRJJRIMS2vr72YQQgghhIQkGgEPQVpej3cPbYOW1/u7KYQQQki9oNUxvPXVeaeec8Njh1BWqfNSi+q37GkH/N0Et1AAHoKknARDmrSBlKOXnxBCCPEEpZrHHzuuOvUclYaHVkepK6GIUlBCkITj0Ckh1d/NIIQQQuoHJydV7T9RiY9+vuSdttRj9elShYZAQ5BGr8fTO1dDo6cUFEIIIcRVb3xxHhcKVMIDG9Hh1r2leGVJrtX2skodTl5QAqAShrWprNbj4bdOAqh//UQj4CFIJpFgZtYgyCR0/UUIIYS4asOuq8grVKOwRIvCqxqrn18u1uDYOSUuF2uQmhhW67H0PEPRVS1S6tgvlFSr9DiaWw0A9W7xQIrAQpSkvl1KWiir1FFJKEIIIV53zBAgbtxdCgB49bNzOHiqUvw5YwyTnj9q9/nGb+MjZ6owsZb9vOmmZw5Dow38En+WkYtSZX0n/51vLqDaxvZAQwF4CNLxPF7dtzEoF+JZ/U8xzuWrsPqfYuzKKbe7303P5CCv0Ho0ghBCSP2kVAdG0LV5TynyizRY/Xex2fZqlR6lFTYqnnCATs+g8eNkzLJKPfR84A9a7cypQEFxzXf7qCcOW+2z9t8SVFYHxnuhNhSAh6AwqRTzeo9CmDT4lnOd/20eDp6sxLp/S7D7SIXNfX7ZfAUAwPMMT7x7ShydIIQQUj+dzlNi1OM1wdiE5474tbxf0VUt5n+XZ7btm7UFeG7xGat9OQ74ek0BXll6zlfNC2r+ukvgaRSAhyCeMeRcLQAfxCkaR85W271a/2C5MLOcAThwsgrFZVoftowQQoivWZbyu1Kq9WtKxWerLgMQUiaMLftx/RXo9ba/t6qUelRUCaO2VysC5zvr7/1lyL2k8nczAJhPwqyrBviKLUU4crbKyy1yDwXgIUjPeKy7cBx6FnwpKADEv0LjhxUhhBASiHR6hpKympF4W+E3Z5HZfMuMI15uleM+WXEJ/xwo83czHPau4a7Dz5uu4NApCsBJgJFLpHiyc3/IJcGVgsIbRryvGGaab9pTipIyLS5dUWPpb/lW++sMIyJf/H4ZufkqPP/RWd81lhBCSMj74c9C6ExGvS8WanD+sgrnLteMKgdMTQQv3xTX8wx/73cumDfeqH9/2UXUNm3tUpEaBcUa/G7Iuw+G+/tBEYD/+OOP6N27t/i//HzrYIs4Ts/z2HDxJPRBNglzwy5hhbELBWpx2/hnj+CFj3Px3R+FUKr1+HnTFfFnTy44DQA4c1GFAycq8e/Bmkmbl67UHIMQQkg9FACRbbXa/HtWpeFx98vH8eXvBX5qEbBtnzB4BcDm4JW3KNU8Xvwk16nnPLdYGDhbsaVIjAEsMcZwxwvHzHPDGcAFwOtfm6AIwAcMGIAFCxbg8ccfx86dO6FWU/DkDgagUFkVFFeIpowfZJZ/U2cN+WlXrmqx+KealcUqldYpKq9+dg5Pv3cad7x4zHsNJYQQ4lO1xVqvfua/yY2BGAK+9Ok5HDgplEn87o/Cmh/4qLGXix2vUJZfVHe898S7p91pjt8ERQCempqK3r17Iysry99NqRdkEgkmtu4SkgvxbN5Tir3HhQ+efw96Lq8tkCbNEEJIqNLqeDxkWDlx6a/52HusApv3lPqtPY5U9rN38fDt2oKAqM3t6cG62mqiu+JggOd621PvVsLUarXQ6WomPCiVwlKvjDGfL8xiPGegLQij43l8f3o/bm8VWEF4nf1l2L51r+3A+aVabm3ZOmZBscbt1+a3v4owtn9D3DLjCDZ80NmtYzkrUN9fgYr6yznUX86h/nKOJ/srv0iDE+eFcrNaHatZGGfPVbRsEiGeL1DZ6gfGGD5bdRl9s2Kx8MeLmPdYK4/2GUNNn9T810Y/cZ6Ln0yPwRjDTxuvYPR1ieA4IEzu2ViECSfxW+zniHoXgL/22muYM2eO1faCggIoFAqftoUxhtLSUgCBlYvEM4Z4JsWVwsKAWhGzrv5atKz2nLlzl+3fqiovt64ZXlFRgVc+LUFqggxj+kU511hjm34sQO8MIdWloMC3OX2B+v4KVNRfzqH+cg71l3M82V/f/VmBdTuFoPvgsZo0RDCgolL47Pf157MzLlwsxNEz5gvL7Tl0EQBwLu8KDpyswtwvTmLK9TEu9dnhM2qs21mNp25vIG4rKy1DgWE+lbFvCgsLEBFmHgjrdHpUVlbCE91XraoZzS8oKMBHvxTgvyMlaBgvxeRhMTaf43LwzICKykqUlgrpLr78mzQO/Nal3gXgs2bNwowZM8THSqUSiYmJSElJ8UsADgApKSkB94E8OjXV302wUnd/2f4E4LiamdL2XKmQW22LjY1B8clSxMeGIyUlxdnmim0SnlvgxjFcE8jvr9qs/bcEI65N8Pl5g7W/3KHS8FZfqI4Kxf5yB/WXczzZX1GRejAmBOBFlTXf8zwDvltfKZ4HAH7bWoSG8XL0zYpz65w13I9Mp79XZLXtUK5QpYxJYwBcxfrdSjwzpTUA5/ts35kSHD1XJvYBxxUgLi4OKSnxMP0OS05KhiLCvDqaTHoVMTHRHvl+E+ZlCYUSYuMaAiiAjpdDIg2zf3yuEK4kwXAcEBMTjfh43ud/kyEbgMvlcsjl1sEWx3F++VA0njeQPpC1vB7zD23DE52uC7hShK70lyMXyGv+KbF1MgAcOM69q2Njjh+9v2qXm6/CrMVncblYg3nf5mHjYt/P6Qim/nLXuXwV7nnluFv9HEr95QnUX87xWH+ZPP/d7y7aPRcAbP6vDJeuqLFqWzHmPtLK5VNWq/QYbWMZdE/5dp0wOfKVpefFbab95UyfceJ3nfAcxgCYfO+J/5XYO65n3tOmxxj9ZI7x0GZt8RThV3Stv9zl6LkCJwGY+IyUk+DG5h0g5UL75V/040XkFahNPpSYSxNehj180NNNC1q19V9hicap2e+BQKnSY1dOed07Boh9xyug0vDgeQal2v+TtwgJFMYccQAoKdeJ1bNc5c3g2xdMQ8Rftwoj8CVlOuQVqm3uuGnPVadreHuCq2EzYwFRhbJWQRGB7d27F71798aECRMAAOPGjUPv3r2Rk5Pj55YFJwnHISM+KaDyv/2ltFKYsHvpihq//VWM255zfQUyvSPT3eu5EdMP4cT5anz48yWrn20/aB7IDnu49qWE/elysQZb/ivFyTwlnv0gOBZwOnCiEk+9dwanLiixYksRZn0YHO0mxF2OfJP9vk1YoOXw6eCsmAHYLq3rKoaaxe0W/SjcNfhxfSHe/PK8zf037irFNj8E4PVZUKSgtG7dGgsWLLDa3rx5c983ph7Q6PV4etdqvN3rBoRJAysFxR9OXlB6pC74sIcP4rahSZg6rrEHWhW8/vemUAKsUWIYRvZNEGe3r91ungak54V8zLEDGvq8jfas/KsIp/KUyGgWiY9/uYRXp7Xwd5Mc9sSCmlq4FdV6lFboatmbkPqjWuVYYHr9ozV3K7W6mgGTX7cU4caBgfM5ZM+NT+Xg2xfcz8U2jr3Ntlgd2tgjep5BKvHtAN2YJw5h5fxOPj2nvwXFCHhsbKzZSpjG/0VHR/u7aUFJLpHg1e7DIQ+gEoT+5MqIyIUCNZ5eaF38/8f1V2zsHZoWLbuI1784j+xpB6DW8GZfeEYLf7Sdr+kveYVqnMlz79a0r2VPM7+TQPe1SKhZbWuOjyXOPOgur6oJ2hctu4iSMi0qq+sO5C3/3gLdis1XsG677f6xlxI47OGDOHNRKV7YqDQ8dhwuB2MMX62+bPM5jvRLeZX9QYEqQ4WURT/m4dkPzohtq8/3lSkCC0EMQLVeU6/f2N5WUqbF3mOV/m6GUz799RJWbPbtBcK2fcIty5GPHfLped0ShBHs0bM1F5FvfnUeX68J3JJrhHjK6TzHqk04YvyzR/DxCuvUudqCxmCw+0gFDhkWqsnNV+HmZ4TU3fOX1TiXb57vfbVch6NnhVz5ssqaSaamFy5frnbts2X2h2fx4BsnrLafOFctHr+sUodftxZjV04FrpbX/8XtKAAPQTqex4JDf0PHB88krSulwfPHmD3tQJ21SyuqdT5f4exYrhK5+XUv6+tr0+ed8uv5lWq9uIiT6ctm+goqVXo88a5/21kb04D70pXAmehaUR3cwQtx3PFz1XXv5GFTX7cO6OxZ/Xfdo+SW195b/ivFuKfrz1yze185Ls57spWiZrrtXL5n7wSev6xCldL6O69KxWPT7lIAwAsf55r9TK3hodG6MVQY4IMpHg3AL1y4gCNHXJ/ERnwjTCrFG71GBFX+t6c/DJz1/rKLyDWZNV/X/NW8Qg2+XVeAw6erxFtpE547go9+voTcfBWeWnAav2y2rv3qTd5eDczVW7OHT1fhpmcOQ6+vad+Qhw7gjx0lKC5z/cKrvEoHtabuixylmhcnFzEG2Ep9VGp4HDgZeJO37p4jzF3YmWO90JSRscJBXSbOdu2ze80/xZj7lfXErWqVHjc+5bng5dZn608gVB9Nm3vS301wmtIid9wyleWVpedsPi8QloevVOrx1HvWaZCOquvrYNEy99ID9XqGI2cd+8zUGT77L12pGSBiED5b6jOPBuCrV6/GwoULPXlI4gU8Y9hXdAl8AC/NG2hWbCnC+QIVZiw6jWcWnq7zw+uuOcfw2crLmD7vFCY9fxRnLipxpVSL5Ruv4Fy+CkoND72e4VKRGs9+cMarbf/3YJlYWmrP0Qq7s9z9qaxSj1+2FOFSkdBOxoC3vrqAW589gq17S3EstxoFTpYwnLnoDJb8lg8AuOGxQ2YBvj2MMfHiigPE0ZeNhhGaQHO+oO47Gots5NlPm2s9clhQIlzs1FZpoVKpxw9/Fpptyy/S4NQF61QATxcFKi6zP5pOS8AHhpHTfV+S1Z1geNQTh8VKIEbvfHNB/Byy5/NVtvOgfeW/oxWY++V57DvuWhokYwBzNAnVxm6PvH2yzrvSBSUaPPJ2zV3D2v5+jUrKa/bhAJxxs1SkI3c9/MmpALy4uBj79++3+7+8vDxvtZN4kJ7x+LvgLPTM/1fxjvJHxUTLEV3GgD1HK/GfC7nfj8+vGamoUuqhMtRoLijWYJdh9NIbuYZzPs3F65+fx6ptxdDzwqSb7QfLsToARxY++vkSck5XIdfibsfLS87hobdOYuLzR3HwZCVUdYxq/7WvFFdKtdDoGH7ZXITyKh1UGt6s7JY9Oj2g0gj7aHQMMxadEdtmjyOj7P52pVRr9oV5/Jz93NmxTx7G5WKNzQuegmINPv0136U2vP31Ba+lkq35t8ThcpGlFTr8d6wC730vfF9Rmoz7jH2o1jLoeQaeZ6is9k3a1jOL3BvAsPxEWPtvCeZ/m4dH3rY/ou/PGvuTXhburP5rKOta4mCutOXnpqPBab6Nz4EjZ6tR4eT3VV2f25ZO5alsL6DnhAsODFD4k1NlCJcvX47//e9/te7zwAMPuNUg4n1yiRSPdOjr72YELMaYeCVeVqkTJ7CYcueCYN63whf/1Qod5n8n/Hvhj3n4bWsxJgxLwv03eq6M4V+GSZA/bayZfFmp1GP+t3m4oW9inc9Xa3iEu7iUuSve/PJCrT9//N3T6JYRjben21/B7vXPz0OrY2jROAIA8K6hj3me4Y5XC/HweBnW77qKd6a3wu4jFejUOkp87u9/Cxcm87/Ls5mKYsvIxw5h4+IsbPmvFNEKKTq3iRJLLwaKD5ZdhFQCPH9feq37FRkC5I9+vgSJBJg6KsLuvsLdgro76edNV3Dz4CSs216CZqnhuKZDLNIb2z+uK0rLdWa3r2uz52gF3vrqPPQ8MP32NNz4VI5fVmWtLy5dUZuVcb3zxWNolhqOhFiZVdpWZbUeRaVaj77+JW6kqQHAw29ZB9oqNY+juTU57ZeLNYiJlCJKIaRt+ju1+Ou1NXehxs884rH3b10DFLZcLtYgNTHMI+c35ewdz2Dk9LfEnXfeifz8fJv/mzt3rjfaSDxMz/NYc/4Y9EE0CXP1374bsb3/tRO49VkhH/amZ3LwomGC3oLva+7wmN4qc9WKLUXihLnftgq/3w9/BlYZQ2P1kp055dDqAuP9svd4JR6y8aVpybjSnTEz4aeNQi504VUtzuWrcfaSCi8vqcnxfGy+Y6N1d79su2b8K0vPYcb7Z3ChQI09RytQVunee0SnZ5jzaa5bxzC1ZW8ZHn3nJNbvvAoAWLahEM9+cMYsz37bvlKHjsXzDEMeOoi9xyrAIJR0e2WJ0FbLXO3FP9XcPfhkRb5VPXh/0BveysYqGsG4Smug2LD7qtnjy4a7euu2C9tNK5Vs3H0Vj3tgVPxCgRrvG3KU3V1i/MR567tBlqO+0+edwrrtJWKucn113EZfmN4iME3FM36uTnr+KD5f5dpdsdqs33W17p2CnNMBuEKhQGpqqs3/xcbGeqONxMOEMoTaoCpDuHWv71bgsrdEsWndWHuTc+zx5Apm/vDcB2dRWBI4lWiO5VZj1mLHUg6MEyyNt8nt5Qpb3umwNRjE8wznLwsjrab5rpNfOGq234xFZ7D/hHtlKrU6XryD4cgFR22MfZBzplqcA/DxL/nYlVOBzXtKMe9b6zsPtaVUD31Y+N2fXngGYEJaxxbD32hduZ6eztU2phg54retRfjD5ALAWEVj6crL+GB5YNWkDwYaLY8vf6+9LN3U10/gv2NCmp2nXvkLBSqs2CJcUFstne4FxjtDbxknG/t7CDwAXC3XiZ9xtu4Su6soiCqfucqpAHzQoEGYMmWK3Z+PHz8es2fPdrtRxLtkEgluadEJMlqIJ6RNm3tCzHPX6e1PYjPeCrx4RW03X9bd28Cu2HG4HGcuOl8HmOM4qDS83Qut2mz+r1T8t9qkPFZ+Uc2I2VUb5b30LtzaNR3ZO5ZrXeLt+z88U+v7fIEKGwyjTcZWbttfhjMXlXhhSd13nkyDX3sT4owTYN2dy/Hj+kLkm0yQW7+zBOOezsH3fxY6FNztyqnAPhsXRlodX+fEaiOlWu/23Y364tctjlXYWb7hCrKnHcDXawr8Mp/HWSobOd6Lf7pk82+73rPzes14/wyeXGC7CsuMRafFPHmNlqcJ0nY4FYFlZGSgT58+dn+emJiItLQ0txtFvEvL67H02C5o+eAelSW1W/tv7cGTcSLehQIV7ppzDLtyKpBXqMaNTwmLL9z36nEAwMTnhdHdZz84a3dSTOFV/4xW3P/aCZvBqS3LN5oHC5sMt87Hz3S8/N7rn9ddQcY4cdP4nVOt0mOYYcTYmVSquuKULSYXA+5Qa5jNVUpLynU4fUmHnYfL8d4Pefhp4xWbo42mX64jpgspS5a5pMMe8Ux1jE9W5GPP0ZoA2vhvd7/fnbnD9u26Qsz60Pzuyx0vHg3JyZwfr3As9cD4fiit0KGsUo8zF5Xixdof20uwdW+pU+d9/qNcp/Z3lt07Kob3WSBOvLaXv+1uNSJHMlVNBwvyCtXYc7RSvIiZ/MJR7HWxWkt9R3XAQ5CE49CuQTIkwTAUEaImP3+07p3q8M43jlUlumvOceQXaVCl0mPW4rOoqNbj+z8LbY4Q5+arcOiU9YepuykS7njorZOY8pLtvGxbjLc23anr7ciS1UfOVuGWmTlmX+bGSbeucmWSVF027LpqM4A1bsvNV2HlX8X4ZMUlmxc7ti6+hj58EGU2RgvtBcpXK7T4y8H8c3sHceTTrLRSZ7cNVYY0sfeXXax1hJvnGUordPhmrfniR2oNjfLZY1k56v7XTogX81v3lWH7oXJMeC7wYwdjIPnHjsDKT65W6THmycM218twdICiNnWNYJuGEuJnsWFbcZnO5h0FQnXAQ5KUk6BvSjqkXHCkoITi7SvjJCBfpXZYXostsVNq7s8dV/HY/NPYcajcB61yXF6hWhzxtzWaa2rTnlK3z7fwRyGQfvUz+3MBft5UhKvlOodG2KtVevy9vwzT3jyB/CK1ePdBOI4wMff22UfE3GsAXqnNabYSqEU36u18h/57sNzm36i2jglr1Sq9OAqac7oacz613Zd6nuF7k9rjC364iO/WFdR5h8eW2oKRY+eq8e/BMqzYUoTiMi0eeusktu4txW8WCxlxnJCWZVkLWq3h8f0G8wWRCko0lK5ih/h3aviPZYnK03lKPPHuKbz22TlcrdDi34O+mwcUbGYtPgulmoday+PNL8/j8OmawYUKBwYL3FXXJ5G/F9ILVE6VISwuLsaFC/bLhFEd8OCg5fV4c/9mzOwyCHKJ7dUw/z1Yhs6toxEd6f/VMi1XJ6vvnv9IuL39+arL+GZtAda+18mpsnYl5Vr8s9+5LyvGhODE0QlNr31+DsN7J2B8dhJSvFCCyhXvfJOHnzf5ZnVRYzWAzR4I5k/nKTH19ROQyzhodQw/bbyCs5dUGG+oJmKsImKcBPvY/FO4fViy2+e1xVghBahZnc6R0SvhFrR5wF3XbXqhbjfD4dPVaNTQ/ntIo+WtLgiXrrReCOXiFQ1UGh4RLpbN1GiZmNrw5pfncTpPhT1HK7DmnxKMHdBQ3O+PHVdt3tavUOrx+7/VeGxSzbZXlp5DZotITLuliUttCmSuzL8wpdLweP3rqzh9USvW3t9ztAInzlVj4vUpKC7Tinepxg5oiOc/yqVykXYcNJkEuX7nVazfedWjfVXX52pdKSa2/l4J1QEPSVJOgsltutkcAVdpeNxgKD1n9MtbHRAX7dRbxaPedfO2fbAxLrBgvMU9YvohLJndFi0aK6z2/fugEh3aVqNd80gAQiB06oISC35wvqKDM8FrtYrHii1FWLGlKKC+FF2ZWOkrpuULK5V6RBtqChsrRBhHBH81lKSsUtoOYA+dqsKhU2fRuqn1+8FdJ01WtDQG4AUOVL+xNQJub2ly09z4MxeF18t0Eqs75nyai0nXp6Bjq6i6d67F6TyhXZZzHo6crcJVkxKkVUp9nbWh6+sNvN1HKureqRZfrraeRHzkTBU27ynFxOtTzC7njO+vfccrsf0QjYTb8783/ZcKSJxHdcBDEAegWVS8zS8My+AbEGphZ087gKsV9b8sUKC679UT2JVTDqVab3arduU/Vdh5uBwfLL+EVw2lEevp933QM5YvBITVJgEhgNPVkTLjb3+ajIov22C7Tr299BRb9hytwMe/2F9Z1B27ciowfd4pvPd9nlXlGVeX7QaAHMMtfdOltQFgzJOHxdQI49k+/TW/1rS5whIN9DzDcA9NTPWVwhKNWM0G8MGFhcnxl/wmjKA+9d5pn93lCnZLfs3HzTNy6t7Rg75d65nKTKGC6oCHIC3P47Edq6B1ciGeW2YcQfa0A1ZLhRPfePaDs3jorZOY8NwR6HmGH9cXolrFcDpPqIlrrMPs6wh85vvuLQUdqr74/TLGPHnY5duzVUFaW/78ZTXWbS8RR7+9YeW2YmzdW4qfN10Rg+en3rNdMs0Rj847JZbstGRMWzGmI/24/gp4BmRPO2AWsBrdPvsoDp6sgk7PsCsnsOZS2JJfpAZjDLfPPoo9x9wb9a7LmUsqlJTrkD3tgFk6nGlOM3HM938WotTHZRM/W0WpJs6gOuAhSC6R4J1rboDcog74kbOOfcjd+8pxZE87IC7bTXznXL7wpaTXM3z662VcreDFlBVASCF6zsEFajzF3VvRoerrNe6NFnkqbcMfTBe1smXU4zV34kxXK3XGa5+dx+KfLuHRee6vvOiIgpKa16PQ8G/7KVFCYC7kwdt3oUAFpcq/F1qTXziGp94TLrILizX4arUQZH1qZ6K2O7btKxMXLXO4Kg4JSD+uL6x7pxBHdcBDEANQqKy0Gii1vL1al3e/y0P2tAPInnbAa5VKQrECiiPe/tr2ZOicMzRSFOjGPGGd5kXMGRfx0Op47Mpx/wLP0VVT3fH3/poL4ckvCPn+Wh3Dpj2l+Gxl3cHquXyVVTunvn4Cfzk5odobjCseLvjhos3cbW84fNr98nnEf/45EPh3d/yN6oCHID3jseT4LuiZ52pzDnnoILKnHfBIzVFTlvVjicBeKb1nFlI6SKCrUlFNXHsYY2Ie6bHcalz/qGcuVnYc9l8wUFqhw7frCvH8R2fFBWcsJ3fqeYYLBWrsOFyOW2bmIPeSClv3loIxIdc60Bb5+XUr5WET4i6PlrZYvXo19u/fj48++siThyUeJpdIMaf7MK8c23RBltULOrlcEsyICvgTEjqGPFQzMdFYa72+OH6uWkwXs7xTNezhg0iKlwMArpbrcK+hDrxEIqSh3PjUBWz4oDPe/S4PT0xqKj5v9T/FuKFvotfabG+y7KIfna+yRAgxR3XAQ5Ce8dhzJQ89ktK8uhiPsaJK66YKfPxsW5eOQYtYEBKaArmkpLtslXZUaW0PNuhNUsBX/1NiFoDP/zbP7QD8+LlqHMutNqt1Dgh3I+xVvSGEuI/qgIcgnjHsL76Ebg2bQOqD1ehPXVCKFQSy2kRh/uOtHX6uu0t3E0KCk0YbWvM/KmxNTDXpgh2Ha3LheZ7hsIPzPbbuLUWP9jE4fq4aTVMjxJF2o/0nKvHr1iIxAL9SqkVSvLze1i8nJFBQHfAQJJdI8UD73nZXwfSmAyerxImbt8zMgVZHKSaEkPqvuMz23bzayrryDFi+URiFnv2hMEEze9oBlFXp8Pj8mrKKD711Eowxq0nrVyu0eHnJOZy9pMLLS89h+8Eys9KHz35wxqqc5YTnaB4XIb5AdcBDkJ7n8WtuDvRO1gH3tKvlOlz/6CExIHd3aWNCCAk2m/dcrXsnC8dylRaPq/HK0nPiIjVllTr8trUIt8wQgunp806hWqlHSbnOrPThrpwKVKt4lFboMPn5o2bHpAFwQrzLqRSUQYMGISvL/rLT48ePx6hRo9xuFPE+CeeD3BMnTX3dOIGzADGRUvzweqZf20MIId72zVrn6yUv/KEmNU9jyB2/dEWD1MQw3PjUYcyZmo6FFhMl9XxN7fnsaQewcbHwXf7PwTJotAz5xRo8Pv+UeEypJPC+IwipT5wKwDMyMmr9eWKi92ZjE8+RSiQY09w8uC0qDaxl5iuq9eIkTkIIITUKr9Z8Xo+YLnxOXq3QYc/RClRUO7dwT6HJhNCDp6rEY371UjsPtJQQYg/VAQ9BWl6PxUe2Q8vXfFCXlAdWAE4IIcRxRaVanM4T8snf/PJ8nfsbJ8bb89rnrq1ASghxjEcD8NWrV2PhwoWePCTxAgnHoVdSU7M0lH3HacEbQgipD0xHyF11/BzNySHEm6gOeAiSchL0SEoz2/bJirqXSiaEEEIIIe6jOuAhSMvr8fLeDXih2xC/lCIkhBBCCAllTi9Ff+edd9qt9/3VV1/hzJkzbjeKeJeUk+DB9r29ugomIYQQQgixzekA3FgH3BaqAx4cOAAJ4ZGgIlOEEEIIIb5HdcBDkJbn8cyuNZh3zSiESSkFhRBCCCHEl5zKQcjIyECfPn3s/jwxMRFpaWl2f+6OX3/9FQMHDkTHjh1x//3348qVK145TyiQSyR4r88YyCWUgkIIIYQQ4mtBEYFt3LgREyZMwMSJE7FkyRJcvHgRI0eOBO/npdSDFQNwtqKElhomhBBCCPGDoAjA582bh0mTJmHq1Kno3bs3vvzyS+zbtw9bt271d9OCkp7x+OH0AegZXcAQQgghhPia05Mw/WH37t14++23xcdJSUlo164ddu/ejUGDBpntq9VqodPpxMdKpbCYAGMMjPl2zLegRI1DZ9TIu1ph/gNm858wNs+8mczq55bPs3U809/V1q89gOuGHQcqrH9ACCGEEFIP+CP2c/R8QRGAX716FYmJiWbbEhMTUVJSYrXva6+9hjlz5lhtLygogEKh8FobbTl/WYuzeRUoKBGWfDdZeNK8AomN7Rxnu0aJnc1OHZtxDPmyEjTSJUBCtVAIIYQQUg+VlpYCsB9TeYNx4LcuDgXgFy5cQE5OjkMHbNasGTIzMx3a11EKhQKVleZLpVdUVCAyMtJq31mzZmHGjBniY6VSicTERKSkpPg8AE9OZmiaIkNKSopPX/y66HgeX58qxo2tm0NmmIi5eMVBP7eKEEIIIcRz4uPjfR6DeTQA37p1K2bOnGm2rbKyEmVlZVAoFJDL5SgvL0dkZCQeffRRvPHGG863uBaZmZk4fPiw+FitVuPUqVM2A325XA65XG61neM4vwTBxvMGUgAul0pxT0ZPfzeDEEIIIcRr/BGDOXouhyZhTp48GXl5eeL/jh8/jvT0dPz888+orq5GWVkZdu7ciaZNm+L+++93q+G23HHHHfjss8+Qm5sLAHj77bcRHh6O66+/3uPnCgU6nseyMwehoyoyhBBCCCE+51IO+LZt29C6dWvcdNNN4rZevXph8uTJWL58uVkKiCdMmzYNOTk5yMjIQFRUFKKjo/Hzzz8jOjrao+cJFRyAWHk4ZX8TQgghhPiBSwF4RUWFmNhuqqSkxGZetrskEgk+/PBDvPXWWygrK0Pjxo0hoUVkXCaVSHB90wx/N4MQQgghJCS5FMUOGDAA+/fvx5NPPon//vsPhw4dwvz58/Hxxx9j7Nixnm6jKCYmBmlpaRR8u0nL6/He4b+h5fX+bgohhBBCSMhxKZJNTk7GunXrsGvXLvTp0wddunTBZ599hh9++AE9e9LkvkAn5SQY2KgVpFzNy5+WHO7HFhFCCCGEhA6X64D36NED27Ztg16vh06nQ3g4BXDBQsJxyEpsZLatWWo48grVfmoRIYQQd0klgJ7m1hMSFNzK5di+fTsWLlyIP/74A0VFRTh+/Lin2kW8SKPXY8auNdDoa1JQhvRq4McWEUIIIYSEDpcD8OnTp2PMmDH47LPPsGbNGsjlcowdOxbFxcWebB/xAplEgqc69RcX4QGAiHDKqyeEkGDm2wW3CSHucCnq2r9/P3755RccO3YMDz30EAAgLi4Ow4cPxxdffOHJ9hEv4ACESaVmZQg7tozyV3MIIYS4KaN5zUrPj09Mg0xKhWYJCWQuBeCHDx/GoEGDkJiYaLa9efPmuHjxokcaRrxHy/OYs3cDtCYL8UgD8MP6mTub+rsJhBAScLpm1KyBccfIFNySnYTWaTUB+HVd4vDek61dPv61nWPRuTUNyhDiTS4F4I0bN7aZ733gwAG0atXK7UYR7wqTSjG/92iESaXitogw/6eg9M2KxTfPJ2PDB52xcXEWhvdO8HeTCCEk4LwzveZ79q5RqfjfzY1hekszLlqGdul1r8kxsFsc3n/aPFC/pkMM7hqVirtGpXqsvYQQay5VQenXrx8qKirw0EMPISIiAsXFxZg3bx7WrVuHefPmebqNxMN4xnC87Aoy4pIg4fw78v3Rs23QpqnwRcEYQ0FBgV/bQwghgWx4b/cnzC94ohUuXtHg+j7CIMfMKU3x5pcX0LqpAq3ShP8RQrzLpQA8LCwMv//+Ox555BFs2rQJWq0WZ8+exapVq9CwYUNPt5F4mJ7x+P3cUbTulAgJJ637CR7289wOiI9x7K2X0VyB4+eUXm4RIYQEljH9E7Hyr2JMGJaEH/68AokE4HngmTub2dxfynGIipBCq697Kman1tHoZDLwPfSaBLz55QW8/3Rrvw/KEBIqXK4D3rJlS6xevRo8z0Or1VId8CAil0jxdNYAn57zl7c6IC7a5bcbIYQEPbmMg1ZnHiAbA2tL025pjJV/FaN3x1iMvDYRZVU6JDcIs3vs+25shLvHpNpMJ+yXFYeEOBm27i1FWaX9FZDlMv+nIhISKtyuA/7ee+9RHfAgo+d5bLp0Cnpbn/oe9P7TrbFxcRY2Ls6i4JuEtF/e6uDvJhA/S24gF9dbsDXI/MC4RoiKEL6S177XSQyG5TIJmiSHI7NFFBrGy+0eP0ohRWyUDGHymq/1/93cGFEKCbpmROPR25rgh9cy7T5/wrAkV34tQoiLqA54CGIALlWVe6VmbNtmCnESZfsW7s+iv2d0o7p3IiTA0V19ax1a1j1JsD4Z2TcRmS2sf2eppObNERkhRc/MGLMg2p5Hb2uCYXXkg9+SnSQE8hzAcVytx73/xsZ1npMQ4jlUBzwEySQSTG7TzWwhHnd98WI7bFychQ9ntgXnwWijYQP7Iz6kRt+sWMyc0hSDesSjUaL929SE+Ntdo1LxyXNtkRBr+287MU64W2acIBiM/ljU2ezxL291wB0jUzCyr1C697ouceLPXnkw3WzfNx9uKf67eaNwxETanqczdkBDzLCTD16bR29r4vC+37/a3ub2ySOSnT4vIcQc1QEPQTqexzcn90JnkYIy95GWdp5hn3G0u2mKd+YAyAOwPnkg4sBh6DUJmH1Pc7MFOTypSRIF9u56YlKav5vgdwlxMqsqGw1iZZj7cEusnNcR37+aiTH9E9E6LcJPLXSfTMqJ6xhEhEvMUvBm3NkUk0ekAAB+mpuJnpmxdo/z2fPt0CTZvc/We0anIqtNzd3IsQMcL5SQnGD7b/5uujNJHHTzYCrMYQ/VAQ9BHIDGUbGwDG17tI9x6PljrksUc7s9Odpti7tfPsGqvQM1fAHgmsxwpDeOQHiY916Hr15qh+v7NMDLD7awOxpHrPXNsg6sbuibaGPPEGPIfWvZRAiwoxQS3De2EXpkxiBKIYVUymH6hDTERsvgwZt0Pje8dwLC5RweudV8xHlY7wTxAqRBjHAXIEzOoUdmDO4a7fna2zf0S0SLxu5flEs4IFxOAyLEcXeNSsW0W5rgz/c7171zCKI64CFIKpFgcGPnV0l74b7mGNAt3vMNIlZG90/E0dzqOvebcn0MmjZJMbsQknmokoGxOkOT5HA8fYdwq1sRIUFFtf0qCqHurUdbYs+RCvy1rwxzpqajtFKHUxeUIZkDznEAszHRhDdsu/OGVOw9XokFT9j+LOrfNQ6d22Qi95ISM98/CwBo0TgCldV6XCnV4s9FnTHskYMIk3N4aWo6nvvgrLd+lVpNHdcIn6zIt/kzRwco1r4nBCgtmwRu/e3hfRJw/42NcPRs3Z9LJDQN6BaHrXvLxMd3jBTu9JjOcyA1XPqmNtYBz83NxeLFi7FixQp8//33VAc8SGh5Pd4+sBVa3jqQ+mmu9Sz5eY+1wsbFWRR8+4jxOztMzmHR09bByZoFncR/R0ZIoIiQQhFRMzLtqVHqr15qh46tQmuinLu6t4vBdV3jcNOghuA4Dg1i5OiZGev1O0WB5tHbmqBVk5oUko2Ls2p+aBKV2wu+AaH6R1K83CxXPCZSir5ZsZhyQwqkUg7fvdoea9/rjCZJ4bihr3dzxj95rq3N7bcNFfKhoxXO/d11bxdd904BokvbaHRsFYW4aBl6d7KfMuMp0yc4nqdOAofpnZa2zQL3YjJQuDxUZqwDXlVVhaqqKuzZswe9evXyZNuIl0g5CUY1bw8pZ/3yN4iRY+W8jujUOgqvPJiOjYuz0KVt8HxR1Aet0hSIDBeCD5lJDvzTdwg5peGGOr/fvNwOcpl1YHfvWM/cxm7UMBzvPdnGfCNDUKcFeNK4gTWDDSverikzmNkiCjcPNi/pFq2Q4td3hH3WLeyEYGI6aW98du2l6r59RZi0N3ZAQzw6wXa+O+9k+aWWTSKw/E1hYOC5u5vhjpGpuPMG4T2eYshRTksOxxOThL+P6/vUVAZ55s6mHgkENi7OqnN1SGfnXrz1aHCka8plHKaMSrGaFDuoR7zHz2Us0zimf0N883I7q5+vfS+4/nZCzS0m+d4P3kRVderi9lepRCIBYwxr166lCZhBQsJxaB+fbHfFsyiFFAueaI1rO8fZ/LmvpdXzPPAHb675oGqXHoluGdHo1yUOS2ZnmO1n+gW4cXEWUu1UO1GES80Cd09iDLhzZCreN4zMZzRX4LEQHa3KaF5zdyA2SmYW+NkSEylk/AXbYidj+juet94wXo45U9Nr3cdWWkptOI4TR8GTGoTVuorukF4NxHQpQJjv8t6TrfHtK+2x1OLvyVGDTQLNnpkxiI0SRrqlFi9jdKQUPduFY6xJf40fkoTWQb6s+y9vdUCnVu6XlHXEYxOa4NNZ5ncaWplMxnWkPCMBls7OwHev2K5g4wlfvWR9cQQAnCHVZP5jrdDWS8UA6hOX3s2MMYwZMwZ//fUXAGDChAm444470KlTJ+Tl5Xm0gcTzNHo9ntixChp9cOTy1vWF7mtZbaI8OrN7fHYSlr+ZiScmpWHhk63xwE2NxZq9xkI113YWbvua3cqvxcwpTd1qk73RrfFDktAzMwbtW0RhwwedsejpNmiUVL8vkGrTLDVcnJhmGvjVF5Hh5hdyMZFScByw/I2aVLUB3Wou1GVSDv0MJfZsXd8nxslcnjB8+7C6S989e5f5a8AgBG2piWFIbxyByAjnv/JMF7958+GW6GgSjJqmgz08vjHuGhmDR0zuGNw1KhWtmwZ3IBIZIfVZCpUiQirmwScZVv18/t509GgfTRNALdhKNRxquIOQ3jgCKV4sR2tZHMHyojirbTQU4TRhvy4uBeD//PMPKioq0L9/fxQWFiI/Px+FhYUYPXo0vv/+e0+3kXiYXCLBi92GQB4kuQTpjQOrHNmbD7fEtFs8O+qbECvHDX0TIbUYuVaESxAXLcUrD7Zw6ni1LVntjpsHJ6GdoUILx3GQSriAmGD4+kNC/0wc7v36xCkJ5vWrbx3q+XP6as7S1zZu85uKMAnAbxrUEI2SwsAYkBDnfH3+te91wldz2mNYb9dyte+70f3Sdw1i3V+R13QEP9xk2fcGsXLER4dO0GFay9wViXEyhNXycsikHJa/kYmmKeGY+0grrDFMVP3htfbiiqGhzNbXd0S4Z/rFE39rpG4uvVqnT59G8+bNAQD//vsvRo4cCYlEgq5duyI/3/ZscBI4GIRRcG+shFnf3T061ae3QZs3isAvb3V0+nntWkT6JBgFgLgo94MadyUYAqt7xzr/xfHS/cJnWfsWkXh8Yt11ul+4Lx1ymXDh4cuLj/5d4wznF9r73N3uj7g3buj43YuHxjeBTMohwhB0fjizjVUaRm3C5BJEhEl8UhHhm5fbYfY9zdCljfPzV15+IN3p5yg8FPgEE3cn5S+dnYHoyJp+a2FjoMXWhV5SgzBY1dD1oc+edy2VydM4G53gbHqXPZ1b151y9OPrwl2wcQMbgoIJ17j0qdGqVSts2bIFR44cwZIlS9C/f38AwLFjx9C+vffyjohn6Hge7xz6y2ohHlI3T8UOI65NQHy09wJXqYSzu4hGXYZe00C8lekIf95iNwbPzVMjMNdkBUFHZbWJwnVd4xERLkFirNzqC2zEtcJorWmevqnWaQqrEXF3NW8kBMXP39vcbPuL96cDqAl8sns6/hp5St/OceJEy7bNIvHn+1n+jIXsatQwHIN6NHDqNrwxxaFvVhySDSvwPjU5DTcNMk83s3XR9fu7NDnQGQ+Nb4zoSCnSkmSIj5GhWUq41ZyXQNW8kf/vyNqbWMw8FAk7MrBgTM1KSwkXz8uh7onapIZLAXi/fv3Qu3dvdO7cGVKpFAMHDsSlS5ewdetWTJw40dNtJB4WJpVibq+RCJOGzu1ST/HUCEN8tAzt0iOR3TPeMwesw/zHhIoL7z5ee+WFodc0wJOT0nBNR++XGvOEfl3i8Of7nREml6BHpmMLSZkylpBbOa+jOLIM1PSXsaKMvS+V5+5ujhHXOr+4jmnVFFNpyeG4w7BKYuMAXHlUKuWs8j0ZhHaPtCgDaPwOt1Xa1F9sjRoajR+ShJ/nCq/L968JbU5vFCHmIhu1aaqwOVpLHHfTIOHvacakBvjfzY0woHu8fxsUZJIbyM3uAoj54BbfT5YpZo7OgTAtqdmxlgm47VsI6YiMCQtqSST2ByuINZfvm/3www/QaDT47bffhHq3DRpg586diIryzWxp4jqeMRwozgfvqWgyRLRtpnB5VNmSIkLi0/SFrLbR4tLYtUlJCAuqKh3GPHRTP7zueMBnvNCQSjhIpdb57N76E4mtJW2nT+c4LH0+w6wtxnKTxiXFTZcW9wR7FVyMTairT1s0jsCTk8zfXzJDm42rPQaC+BiZzcl8iXEy8edG94xJRWMbE4zvvCEVExyYEBoKHPlMefqOpnh8YprdO37ZPRvgrlGeXwHU29b7YXVH0wGbBjEytE+PxPP3Nsf3rwl3pSzv+FimmK2a79idmjiT1+q+Wsravv90G/EzYuW8TkH13REI3OoticksAIVCgdjY4Bg1C3V6xmNL/mnoGaWgOGPmlGYYek1NoHLb0CSXRikXPtka47OTEBkhMZvE5W3DXZz8Fqjs1QROiq874LNXWcc4kmNPuFzIgY6OlNqswe4JEWESNEuNEC8sVs3viHULhS/7+Y+3NvuvO4zlPW8e3BAj+wqj+KYVTa7tHIs59wrvmdr61F4vtE5TYOU85+cveNNbj7TE2AHWFYwmXZ+CLm1jrLbF2QkaO7WOwpOT3as0VB9EOPD5dX2fBIzql4j+3QKjrK2rjOUnjSR+WN3RtMpP80YReP+ZNhjYPV6sODJxeDJ+c/BvzpF5C9d1jTOrgHPvGPculBx5v4QS6o0QJJdIMb1jP8gllILijqnjGmNA13inn6eIkCBMLsETk5ri4fHeq6E9pGc8PnjGYiGdWr4zGiWGBcXqZbcPS8a6hZ1cmgx7TWY4Jo9IRss0+ykEHDh0bB1lcyGQVfM7Ib1xBL54oZ1Ybs9VGYa+lss4SCXmwS8gjCovfzMTkRGe/Ts1Tlj90lDLd9otTdChpTCi/sJ96eJ+SQ3kaBDj+rk5jkOUk6tDelt4mMSsesTbj7bE+vc7Y+yAhuia4fiEzZSEsHp3QeuK2u7iWV609esSh5lTmuG7Vz0/T+wJByZPO2vBE+bpeh1bReGjZ4XPU3+nVdm6MSfcNeOsVmS1TJ+7eXBDNIiV4dYh1ml1zVLNR8xfuj8dTZLDxDsUE69PsXrOsN4N8NFM26vEOspT1VuCjf/LFxCf0/M81l88iaFN2kAaJKUIf3g9ExOeO+LvZli578ZG+P7PQof3z+4ZL97m9vZogCJCikYNHR+hf/nBdLEGbyBzp0RWxxZhuH1kKjiOM6vhbEkq4dCoYTg0Wl6sJrNqfkexTGS0jRq8zlo8sy2Onq3ChQI1tHqG3h1jcbVcJ/7cdAEaT5l2S2OoNTyWrrxc637t0yMdrlYSEyWD3tnlLf2IA4fUxDDcNKghurVzft4Aqd3yNzPFOwfDHj4obu/u4b6Oj5GhtEL4e7Es3+oJtu5+tGkq5Dz7Oq3qhr4JVgvSWV78pDs4OXTaLU2w+0iFOBgjkQCW9RgYq8kfbxAjxx0jUzCkV7zN4ynCpY7X/LbzMnny1bP1+wSq4Ii+iEcxAOVadVBVDnIkrcCbHp+YhuRaql3cNKgh2jRV2AwOjauGNUkKw3N3N/d4UFUbyxUxGzUMt1s6LhDqedemZ2aMWCHEFSOuTUCnVjXPt5X+06VtFKbeVPMahsklYmlDT49EA0D7FlEY1jsBN/RNRGKc3GsVZfplxeGPRZ1x8+Akm6NYVpx4Lzw0vrHZcvXBIFohwc2DqVqDu9IbRViNpDaIkQlzKiSc3dV6PeGuG2rex5ajvq4Yc52QhtU3y3Yqra+nTP25qCbHPEwucWu9gdrqpttLs7LMH29keLxqvm/Syjq2iqx7pyBHAXgIkkkkuLVlZ8iCZPQ7EIzql1jrVb6xLrRlniBQs2qYP8psRSmkZqtnJsXLsehp4TaqMZ/9x9czcc/oVKtqD4GkVVqEuACQoyxvdT85KQ1J8bV/UTdNicANfZ2vahLo5jyQbnUxZsmYU/+tk0tYy2WSoJp8NbxPAh7yYupXKGmWGoGp4+zfkXL2veQoDkIRfuOkRHtBsy1P32End9/w55HioYn27nhyUprHRvUZhFKBVhsNmln87M2HWyDGxveYkTcGIkwZV31+8Kb6X00leD41icfoeB6fHd8d8nXAf3SgWsaXL7XD3aMdm3jCGf4XFSHB249a16QOlKIzGc0jcX2fBpg5RZjQkxgnw6QRKR4ZRfKW1MQwpCTInUqRMX6Rrni7A5a/GTil8Lzh+j7W+chhtSzdbSv/05hTn5oYhtuHJWNQPS0N1zQlHJ1dWKCH2Ga5TL2vlq0HhDKgzp7T1oVog1hZQE0QHFnHIMBjE5rgofGOB6i2+sdWSc5rOsSiZ2asVxbLWvR0a/RsX3ca0iRH7tDVE4HzjiM+w3FA27iGAZ9y4C3vPtEKK+d1FBcSsCcpXo605HBMHlH7B4LlKA8DbFbICKT+fvoOIfjeuDjLp1+Y7hhxbSJm39O87h0txEbJfJr240sLn2oNuYxDZIQE13Ss+XIb3rsBnphov0rHA3WMLvXNihNr/BISyOKinRs4yLTxvv7pzQ41tbQNTD8WF89og2lOBLyusjVwc8fIFAzrXVN9K7u7Ag1i5Q7noV/fpwHus1gh+JqOsVa17DcuzvJqDe/MFlG1VpgKRdQbIUjKSdAvtQWkXGi+/J1bRztUncHRetKpiWEYcW0C/ndLY/FDu116JD55rmZm+MbFWT5dwt7XassxnHVPM/Ro7/qIY1SExG6eoj3+qNHrDx1aRqF1UwU4Dnh9Ws2Xd6fWUU4tE0+IO743pHv1dGExLFeMM8y5AYBf3nIuJ9lWbXfAeoAkXC4R/4Yymkda5UR7g+W8lBaNIzCoezzaNqu5aLjnBufKPbdorEDXjGhMGFZz1+vBmxu7XcXJG+ZMTbea51PbnbxgFxQf0R9++CHi4+PF/50/f97fTQpqWl6P1/ZtgpbX+7spPldX+ahmKeF49LYmNkdJatM0JQKdWkcjNTEc3dvHQC6ToFWaAtNuqf95bACw0s4CDwO6xWFwjwaY+0jtK3Da0qJxBD55ri2+ezUT0yc4V2bMWKM3VAJxS4wJpb2SG8ityhsS4mnGBcrefNh6BNcb7hqVWueckCG9akaNHZrcbBGBJyeE4Y9FnfHDa97JY7fJIk1xyewMNHewukld7r/R9neRb1Mja/p41t01Nc2bGNbT6NclzmquVf0Nv4MkAL/nnnuQm5uL9evXo6ysDHyI5y67S8pJMKFVVsiNgH//avs6b9s1bCDH2AENxYmKzuqaEY2X7k8XH1OlBdtqS+t57X8tAAgTkVqlKRAdKa1zAqE9/lgsIxAwAH06xeKLF9uZ1fYmpL56/l7z9LRn72qG1oZ6/00cWDDN1icFx3E+nZzu62lCLZt4Jrh3xeCeNRdIETYKHARLaqQ7giICCw8PR3x8PGJiqGarJ3AAWsQk1OsrS1OTRyTjubub1bqMvCJcguQEuUs5xsQxy9+oufvQ1DDz/sOZ1hc6vTsJt1gtl1UmzuE4zqcrrZLQZre6iI/YSlX4+Dmh8pRlMGeaEmd8nmWd7VDQu2MsYqN8txzMTYOsV6EdN9B627DeDaxy8p1xQ7/gWCSr3i3Eo9VqodPVLGahVCoBAIwxMB+XoTCe09fnrYtGr8dTu1bjnV43IEwaOJUvvNVfQ3o1QFpyeK3HHdQjHg+Pb4wwuSTgXi97Au391aFlJHLOVJttYwxi+xrEysx/gJqf/fBaeyz5NR8bdpeCMYYNH3Q2+7knBFp/eZJpP3doGYmkeLnbv2d97i9vCPX+Gt67gVO/u7f7y/S4nMnYMmMMbz7cEo/NP4VWaQo8cmsTMMasShn653U0/1y0+qmH++zOG1LA8wwjHyvzye9rHHEf0jNePF+TpDDwPMPh01XitmfuaAqNlsetQ5Kw8q8ip8/TPFU4z7RbGoExvV9iP0f4LQB/55138Oqrr9r9+c0334ylS5c6fdzXXnsNc+bMsdpeUFAAhcK3q/wxxlBaWgogsG6nMMbwZHp3lFy5EnDt8kZ/FRcVQc7sv9UjwjgwnQpXS6547Jy+EGjvr+cmx2DSy+YBuEqlQkFBgfj4m+eTMfmVQpSVl0EqAUqKSwAAenUJ7h4Rjr8PcGb7e1Kg9ZenaDVaVFdXi/328LgoxEZVo6Cguo5n1q6+9pe3UH85x9P9VV6mNnts+jmSFKe32q7VaKGsZlafN6nxGtxzQ4zXPodqc7WkxKyNlrz5HvPl73v3iHDxfH3a69GnvQy//WXdhrHXSvDb1rqD2c+eTcY9bwgrUkslQEVFBQBAzlWjtFQYhPXl36Rx4LcufgvAH3nkEdx33312fx4W5trt51mzZmHGjBniY6VSicTERKSkpPglAAeAlJSUgPpA5hlDfnU5kiNjIQmgdtXdX659QCQ2bIgUu7cXC/Dc3c3Qo31M0FUpCcz3V81rlBArQ1pqDFJSLPO9CzGsb1N0aKNG80YRePmBGKSkCBMFf3/XezVgA7O/3CcPq0BkZKShnwuQlJSE+Bj3P9rra395C/WXczzdX0OSGHYdZ9i6t0w8rqAAg3qmYtmmU1gyqy1SUoTR0ZHXyZAYJ0dKSs3I9z1jOAzq1QANHC5b6n7Q+shtjfHblmKcL1CjQUICgKs2PjMF3nuPFdg9p+cVmL02xn9v+MD2+Rs2uIqCYi10evuBeLO0VABCAP7BM23QJCkcX/9xGPHxcYiPD/f532TAB+Dh4eEID/d8zpVcLodcbv3Hw3GcXz4UjecNpA9knvH4+NhOvNBtSMBNxPRGf9V2vG4Z0WicFI7wsMBJxXFGIL6/Hp+YBqkE6NMpDnHRUqu2GVfmbJcufPz0zYr3WdsCsb/c9dSkplBESMBxHBonhSE8TOKx368+9pc3UX85x5P9JZNyaBgvh0zKQadn5sc0/LuFyUJeo/pZ5x77YxGYGwck4cYBSciedkBcHKe2/vDWe8yX71njub5/tX2d510yKwNzv7qALf+V1nk8AGgQKxcndXLg/PI36ei56l0OOKmbXCLFKz2G+7sZPvHMnU2RVMuCO29Pd748HqldRnMF2jSlRVx8Jd1kQY2v5/iwZBohxK64aCnKKp0r9euv2QOWi8n5Sm2FEYzC5BLU12JWgTX8acfff/+N+Ph49OrVCwDQuXNnxMfHY8+ePX5uWXDSMx57ruRBz4KrnKMrs9SH906gShA+1KJxBGIi6bqeEOIftibARYRJxJKEvvL8vel2l7efODzZp22pS2qAV5xyZfCa4wJr9WlbguKbsnfv3sjNzbXaTmUJXcMzhl1XLiArsRFcLK/sFwufao2bnsnxdzNILZbMzvB3EwghIYrjOKtRZJmUQ1y0TCxJ6CthMg72ioxJJBzkMg5anXlrg+jr2GVfvdTO6ec4WsSkdVoEwg1zuX58PRNxUVIUFamcPp+vBMXQoEwmM1sJ0/g/aQCV0AsmcokU0zL7QC4Jrv5zdjlyQgghIcYiWPtjUWeffXc8cFMjm9s7t46y2tYkyfqObnSkFM/e1cxqe33SxMV66x1bReKVB9PFx8a5RLcOqVns7uPnMhClEOKaxDg5pAE+whgUATjxLD3PY+W5I9DX8xVFjX+ghBBC6j8OQEpCmFlQ5kvNUmrSXJj4f7YWCbI9pCuVchjSq4HNn4W62CgZenUwr9XePj0SD9zU2E8tch8F4CGKrweLRfTMjHFoiWFCCCGhITZa6vOgLDHO+RF2jgNuD7Bc8GDz/jPWKykHEwrAQ5BUIsGN6R0glQTvyz+gWxxefiAdN9pYxpYQQkjoiY+RISned4Myc6amAwAevrUJACCrrXWqSW3uG2ueshLYCRP+Y5xMKeGA8dn+ubvhDZRUG4K0vB6fHd+NezJ6Bl0e+Kr5HSGTcuKiOfY+sL57lcqxEUJIKLl1SJJPS/n16xJn9lgRbv/79M9FnVFaqcOtzx4BwFlNLPzh9Uw0dGEkPZRIJBwevLkxlm+0XrX6t3kd/dAi99CrHYIkHIcuiY0DahVMR0VGOHbBkOJAfVFCCCH1h8RPBaMdKXUrlXJIjLO/JkVt61WQukUrgmswEaAAPCRJOQmuSa7fM60JIYQQX4iLqgmlZt3dDA0byNGmqbDqZmKczMaAUPDPwSLuowA8BGl5PV7dtxGzu2YHXQqKpWs6xuL95ZfMts1/jFa3JIQQ4n3P39scLZtEYN3CTgCAwT1rqpg8PjENGemRaGRjoZsgvAEdMEzLEQYzCsBDkJST4L6MXpBywTsJ06hxUjg6t47CwVNVAIA+nWKR1Tbaz60ihBASCgZ2j7f7s0E9qKSgJ3RsFQW1tuauwbWd42rZO3hQAB6COADJiuh6OeP61f+18HcTCCGEEOIhY/rXz2pnwT8ESpym5Xk8tXM1tPV8IR5CCCEkkKx4u4O/m0ACBAXgIUgukWBB79GQB3EdcFOTrk8BIJR5IoQQQgJVbJQMUQopGsRSAkKoo3dACGIAzleVonl0g3qRhtK2uQIDusVBKq0Pvw0hhJD67ObBSRhHi8iFvPoxBEqcomc8vjm5F3pWP1JQYqNkeOG+dH83gxBCCKmTVMJBLqPwK9TRCHgIkkukeL7bEH83gxBCCCEkJNElWAjSMx7/FOTWmxFwQgghhJBgQgF4COIZw7GrheAZrcZFCCGEEOJrlIISguQSKe5t18vfzSCEEEIICUn1PgBnhlFepVLpl3MrlUoolUpwAbTurI7nsfL8EYxplglZAJUiDNT+ClTUX86h/nIO9ZdzqL+cQ/3lPOoz5/irv4zxJqsjy6DeB+AqlQoAkJiY6OeWEEIIIYSQUKBSqRAZGWn35xyrK0QPcjzPo7S0FBERET6/YlQqlUhMTERxcTEUCoVPzx2MqL+cQ/3lHOov51B/OYf6yznUX86jPnOOv/qLMQaVSoX4+HhIaskyqPcj4BKJBAkJCX5tg0KhoD8WJ1B/OYf6yznUX86h/nIO9ZdzqL+cR33mHH/0V20j30aBkwBMCCGEEEJICKAAnBBCCCGEEB+iANyLZDIZXnzxRchk9T7TxyOov5xD/eUc6i/nUH85h/rLOdRfzqM+c06g91e9n4RJCCGEEEJIIKERcEIIIYQQQnyIAnBCCCGEEEJ8iAJwQgghhBBCfIgCcEIIIYQQQnyIAnBCCCGEEEJ8iAJwQgghhBBCfIgCcEIIIYQQQnyIAnBCCCGEEEJ8iAJwQgghhBBCfIgCcEIIIYQQQnyIAnBCCCGEEEJ8iAJwQgghhBBCfIgCcEIIIYQQQnyIAnBCCCGEEEJ8iAJwQgghhBBCfIgCcEIIIYQQQnyIAnBCCCGEEEJ8iAJwQgghhBBCfIgCcEIIIYQQQnyIAnBCCCGEEEJ8SObvBngbz/MoLS1FREQEOI7zd3MIIYQQQkg9xRiDSqVCfHw8JBL749z1PgAvLS1FYmKiv5tBCCGEEEJCRHFxMRISEuz+vN4H4BEREQCEjlAoFD49N2MMBQUFSElJCajRd8YYqnVaRMrkAdeuQOyvQEX95RzqL+dQfzmH+ss51F/Ooz5zjr/6S6lUIjExUYw/7an3Abix0xUKhV8CcON5A+mPRaPX4+X96/HONaMQJpX6uzmiQO2vQEX95RzqL+dQfzmH+ss51F/Ooz5zjr/7q65z1vsAnFgLk0qx8Nqx/m4GIYQQQkhIoiooIYhnDCfLisAz5u+mEEIIIYSEHArAQ5Ce8fjp7CHoGe/vphBCCCGEhBwKwEOQXCLFs10GQS4JnPxvQkKJ5uJvUJ1419/NIIQQ4icUgIcgPeOxNf8MjYAT4if6q/9BW7DR380ghBDiJxSAhyDGgLMVJaAUcEIIIYQQ36MqKCFIJpHgrrY9/N0MQgghhJCQRCPgIUjH8/jh9AHoeEpBIcQf1Gc+BQAoc17xc0sIIYT4AwXgIYgDkBCuAJXxJ8S3qnbdDaarMjxiUJ9e7Nf2EEII8Q8KwEOQVCLBsLS2kEro5SfEl7SX14HpKq2264p3QV9x0g8tIoQQ4g8UgYUgLa/Hu4e2Qcvr/d0UQggAZc6L0Jz/zt/NIIQQ4iMUgIcgKSfBkCZtIOXo5SfEU0pXNrI5um2pYku2D1pDCCEkkAVFFZQDBw5g27Zt4uMpU6YgJibGjy0KbhKOQ6eEVH83g5B6gZnU82RMX+fcCqYptrXVo20ihBAS2IJiCPTq1as4duwYduzYgUceeQTFxba+wIijNHo9nt65Gho9paAQ4q6KLdnQXdns/BOtCvHTtGhCCAkVQRGADxw4EO+//z5mz57t76bUCzKJBDOzBkFGkzAJcRtfeRJMUwoAUJ/+xLVjVJ+H+vSHHmwVIYSQQEYRWIiScDTaRog7eG0ZdGWHYDpyrT4x36VjMc1VAIDmwnIwbTm0hVugPPaWJ5pJCCEkAAVFDrgztFotdDqd+FipVAIQ8jSZj9deN57T1+eti1avx6v7NuL1HtcjTCr1d3NEgdpfgYr6yzme7q/q3fdDV7QN4ORmx+R5PTgHJjjrS/cBADQFNekr1fseRVS/VdBd3Q/txV8RkfG0R9rqCnp/OYf6yznUX86jPnOOv/rL0fPVuwD8tddew5w5c6y2FxQUQKFQ+LQtjDGUlpYCALgAG3F+Or0HrhYV+bsZZgK5vwIR9ZdzPN1fYdUFwi1EpkVZWSnCDNsLCy4DvBqQRkJSug18/HXicyJsHKcsfx/kJo9LSkogqaqEVKdDQUGB2+10Fb2/nEP95RzqL+dRnznHX/1lHPitS70LwGfNmoUZM2aIj5VKJRITE5GSkuKXABwAUlJSAuqPhWcMx0oL0S4+OaBSUQK1vwIV9ZdzPN1fZbtOiP+OkZdDbfh3cnIyylc3Q9zoSyjb9SjiRl+qeY6N48TExEBl8jghIQE6fTS0V2VokJLidjtdRe8v51B/OYf6y3nUZ87xV3+FbAAul8shl8uttnMc55c3rPG8gfTHwjMe6/JOoG18UsDVAg/E/gpk1F/O8VZ/qY/X5Gvz5YfEcwlYrSkplk3hOIm4zd+vK72/nEP95RzqL+dRnznHH/3l6LmCIgC/ePEiVqxYId6O/eqrr5CQkIDx48cjxY8jRMFKLpHiyc79/d0MQuonXmf2UFe4CXz1BYS3uNvm7ozxto9DeZ6EEFJvBdbwpx3V1dU4duwYrl69ioceegiFhYU4duyYw8P8xJye57Hh4knoeTtf/IQQl+lKdgAAmN4wAZzXQHnoObv7q3JeMt/AeJhWVlG5WNqQEEJI4AqKEfA2bdrg/fff93cz6g0GoFBZRWvvEeIFmgs/AQDK1/cy286rLjv0/Mq/RyOi3UzxsSrnRUS0muq5BhISQjSXfockqjlkcZ383RRCzATFCDjxLJlEgomtu9BCPIR4EdMIVYbUJxYAAHj1FfePyWtRuirN7eMQEipUx9+GNn+dv5tBiBWKwEKQjufx1cn/oKMUFEI8z2ICjr7skAsHYeDVhWC6aovNPMD0rreNkBBRvqGPv5tASK0oAA9BHAc0i4q3qr5ACHEfU9urr+/kH5y+GurcL8WH5Rv7gldecL1hQUxffQGavF/83QwSRPjqXJMHGjBe67e2EGILBeAhSMpJMLBxq4ArQUhIfcA0JR44ihCsq468DADQXv4DfNUZMG2FB44dfLQXV6L6wJP+bgYJEurcrwEAlf/eJjw+9T4qtg4H06tqexohPkURWAjS8nrMPbAFWp5uZRNij776AjQXlnnwiE5Me7ZIM6nadZfhX0Jgriv6F5U7JgIAlMfmeqBtgU119FWnuo+ENuXBZwAAuqK/DFWFAL7iKJQHn0X1oVkAgMrtE/zWPmfwWlvLd5H6gALwECTlJLixeQcaASfEDl5zFRUbeqF632MoXdkIvKbUp+dXHX/b9g8MWSy88hJ0Rf8CqJnkWR9Vbp8AfVmO4RFF4MFOX3HS5+fkK0+J/9Zc+AGas5+h+sAz0F3ZCma40NVXB25qV/nadv5uAvESisBCkITjkBGfFFDL0BMSKBivg+rEfOMjAEDVjolieUF/qpmUyQBeLW7XlewG43Xi0sv1he7KVlRuF9IIYG/BIhI0KjYLC8Dpy4/5tR36q/sAAJXbRgEAKjb0qm33gFC+sZ9PzqM578m7fqQ2FICHII1ej+nbV0KjpxQUQqzwKmjOLDHbpC/dh+p9j0B7+Q9x1Mx57l/wVu2aYnO7+uwXKN/YG7rif8VtupI99lfZDCJMU2z8F0pXNoL6/PdQn/8eqpOL/Nou4hpemY+KLYNQtrYtoC31Sxv05cJdFb7qnLiN6dX2dvc7bdG/4KtOAwDkJ6aDVxfX8QznGe/yVe+f7vFjE9soAA9BcokEr3YfDjnVASchgteUoHrvw+Aq9rt1nKpdd6F633Tr8oAO0Jz7zq1zAwB0lYZ/CCPdNV/EDEx50eTnwoI+zAtf1H7DdAAAbf5a6Iq2Q3X0dWgu/gp9Va5/20WcUr6+m/APXSU43VU/tcL6TlHZ6nTwykviY+3lP6GvPOvLRtmlOvomAIAxBmnpX2Baz/db+br2YLzO48cl9lEEFoIYgGq9hjIqSUhQn/sO5es6QHvxF4QfvRvqM0vcStXQ5v2MsnWZTj9Pk/u5y+e0Ymh++R8dLX4QCmllDOA1AADlwZnQXfnLz+0hrgo/dBMAQHn4Jb8Eu0x71ewuUfn67tBXnAAAVB+cAW3Bnz5vky18pZA7ry/aJm4rW9/d8ycypKXqqy+gdGUjKI/VzEVhjIGZXOAT91EAHoJ0PI8Fh/6mhXhISNCXHjB7rMp5Acr9j7s32sP793a1vto8WOGrjbfSOWgu/Y6KbaOtnqM+/wP0laedOxHTQXPuW+grz9S6W8W2UdDkr3Hq0LymBJX/3upcewDoCjYAFhPImV4NvclkOxI89JWnoD7zsZhi4Wtlq5qYPa7YPED8tyrnJb+mcRkDXmZI1dFe+l14rLoCZhit15cfBW937QHXqI69BQDQXdkibtOX7kfZmrZgerVLdwCJNQrAQ1CYVIo3eo1AmFTq76YQ4nWac19Zb7vwI8p+b2ozCA+GBTv0JXvMH1/dK/yD41C9537oy49aPUd5+AXoirfXeWymqwbTq8C0ZYjY3RPKnJegK9lZe3sqTqJ69721H1dbDs2F5dBcWgVdyX9g2nLoDCN6+rIjdbbLnDBSZ7yToSvahopN1xm20cBCMNFeWunvJtgm3iVj4Ksv+KVSSsXfN5o91pz/BgBQtf1mAICu7BCqdk2B5vwPVs/l1UXQlex27oSGO0vaPGHCuf7qXmgv/ykE+HolAAbVyQWoMvytM225c8cnZpwOwE+cOIFJkyZhzJgx+OEH8xd92bJleOWVVzzWOOIdPGPYV3QJfD2rmECIJePtZHvKfm8KbeEms23lLqSX+Jqu6G87P7FIQTGrdOTY33vZmlZQHp5dc3HCcSbBiOFIlhPWdOZfxFV7HgSvKQGvLoK+4jgAQH3uW1TvexTqk4ugvbQKpl8/FVuzHWqbkfbiLzbPC1iPaJLAoDr9ic3t6uPvAACq9z0GbeEWAABjepsXUppLv0N57B2vtdFIefgFMHVBzeMjr0B1xPexDaujBnjl1mHiRSivumw2Eq699LvdSduWdGWHAQiTuS1V7ZqC8j86gRk+P5iuEkxXBQAoW5shPL90v0PnIeacCsDVajWys7Nx+fJlJCUl4YEHHsBjjz0m/rykpAQXL170dBuJh+kZj78LzkJPI0WknjO9nWxP1Y5JqNr7aL0o4acvOyj8wyTw5rVlNV/MDv6OvKoANQE7B+WBJ03qcRsmrNlY8ZMxPXjVZWgv/YbydR2gyf0KVbvuAVCzqifAQX3mY4uLA9fprv5Xc34akQtITFcFVc6Lte+jKUbVjtvBGEP1/iegOm4daFfvuR/qE/McOKN77y31mU9NGsaE//E6n6+kyZR5de+jLQfAoWLLUJT/0cn0Jw6fR5u/WniGIbC2RWe4ONJeWg39VfOR9cq/Rpg99kaVlvrIqQB88+bNSEpKwsaNG7F06VLs378fa9aswYwZM7zVPuIFcokUj3ToC7mEUlAIAQBt3nKUrWpsFmQGI2PuppGu6B+ocl5GxV/DAcbEFQLrwlfniaXajMGM5uKvqPjrepOdrNN3dEX/oPzPrjUbOA7WgYDhwt94u7tgQ83zS/4TJ4BpL//hUFu1F5aBGY5VfeBpq59TZQf/Ux2zs7CUDRWbB4ApL4GvPIOq3feB11hX/KitFCjTVVrNEXCHvuwQGK+B9vJaVGwdAqYt9/qFHmM8tPnrHNtZVw7V0VfBNOZ54IzXgmkrHD0hACE1zx71qfeFXVX5dR7OenI4sUXmzM5FRUXo0KGD+LhFixbYsmULrrvuOigUCqSmpnq8gcTz9DyPP/JOYHhaW0ipFCEhooqtQ/zdBI/S5P0EThIhTNiSRgEAmF4JfeUpyOI6oXzjtYjN/tfqeXzFMVTvuF14YBipZuoiiwmtNkbYrAIj6/QVveF2d8UmYWGRqj0Pij+rPvAE5I2ExVF4VaGjv6aYf24rn7js96aIu+EMOKnC4ePVB0yvBicN93czAADq8986vC9feVKs+gEATFeB6D7mgaHm3HfCHIU2D4NXXgTTVUEa0xYAULamjWcabVC5baRJ206jas/90JceQmSPjyBP6u/RcxkxVQGqdt/t0nN1ZYdRuXWo9TH1SlTtvAOKrPmQRjWz+KlwUezIiLslcaEs4jSnoq8uXbrg4MGDZtsaN24sjoh/+umndp5JAolQhlBLZQgJqa+M5cIYQ02gbJiwWLwDlVuHAQD4qrPQle6H5oL91e848Xa+5SeGrQDcIq2Nk9jer9bjuP/JpL3yN0pXNqqZ3GlyEeCV8m0BQsidZlDmvIKy1elgukrwqiv+bZNeZVaf3lm2ykwyvRKqo68BAFSnFtu88+EtwgTlq6jaMUl4zIRJmoHCMvhWn/0cmou/gmkrhTtitlJ4XEi/0xsWMTJ9ffwxUTWYORWAd+zYEcnJydi4caPZ9vT0dGzYsAF5ec5fPRHfk0kkuKVFJ8ho9JuQek1XuBE6Y8UUvVA6zLioh/rMUmGfgk3iqpLlmwdbHcNYAk2chGW8/c4YKrbdYLZv1c7J5ucv3ll3cGJoF68qAG86aZa5Xo2mavt4AID63DfGg4l58GL5tqpcm+kNzmKMBUzllaqdd0CT+znUpxcDAFQn3hNfk8rtt/ulTc7cybBHffZLlK5sZH1sTSk0Zz8DAKiOz7OaUO0V+poSfPrKUyhf3wPlHl7K3pP1tpWHnkP1f/+r2cBrhFKChqC7YuswMb3EGRUbe1tv83A/1HdOR2A///wzunXrZrU9IyMDBw8exOzZsz3SMOI9Wl6Ppcd2QcsH/1L0TFsBXenBunckJESZVnMAaiZqai6usNqXr7AuX1hzICHIrN7/uHFDTflDO3SFmyDmfNdBV/SPeFzAM0uDGxc/0pcfEyo5GPLBma5aCFYNwZs71Gc+rbMEo6/w1XkWE+AYjP2vu7IF2sItQVmxQnloptlj44ROZpgIrC/Lger4O+KotDcZU6jAdFAdfQNMdcnwUJjA6Ik5BxWbvZHaIrwPtBd/RfnG3tBd+Usor1h2yCNHV9ey0m/F1uFmq4wSgdMBeGxsLBo0aGDzZykpKUhLS3O7UcS7JByHdg2SIfFQFQJ/KV3ZCGVr26Lyr+EoXdkIfDXdgSHEeQyOVY0QAmOtYcEdXu3Z1Ab1ua89ejwzhtx03ZWtAIRSi5bK1neH7uo+5w+tvgLehdxZr2B68NXnax5qS82q+6hOLIDm/DIwXgfNxd/80UKPUh40BOZ6+9U7vElrsvhU1a67AAhzDgKR+vRH4r+Z6jKYvhraws0eO77ywJMAgCrDaDtjepSubgXG66AvOwimLQOvukKTok1QHfAQJOUk6JuSDqkHZ4r7mq0yR+UbeqJ0ZaNaSymR0KGvOl/3TiHNubxP7cVfzR6rjr4OANCct58/7gx98Q7hPHnCefg6arg7o/KfsQAA5eHnTbYa6idry6A89haY8hKYzsGqEWZqLmDCd/cUcoI1pbU+o3RNW+grTta6T2305cdsls3kq86Ii6gAgObct+DLc0zuJhjuLmiuovo/YfKrrdQOj/LiQI/OZGl2f7Nfm985xoo+nmYagAOmczs8yzhRu2xVmiFdx1g/vArlG3pCe9nB6i4hgOqAhyAtr8crezcEdQpKbWWOyta0FgLxAMnLDDTBsNKjJzBd7YtYhDrz9BEH/lYsK5wYAkDVifl1n6sq1+F28dXCvpoL1qv7uYuvOmu1TZP7FdQn3jU8qglKNPlroSve5eCRhedxTAdd4UaUr2tf++66CijFuujCxD7V8br7UXVSyNWt2DLIqYmNNeXlGDS5n7t4oeGielBf31HlG68FIFzUaAs2iBMVNRd/c3iipnHhKm/TXf3PY+knpiz/xpjhTlnl36MBXg3TC3/tlW0Orc5bXzlVhtC0DjgAzJ49G8OHD0d4eDjmzp3rlQYSz5NyEkxu0y2oR8AdYVwRL270JXBBnm7jCZYjXbFD90CiqL+rBnKgOveOYIyBrzwNXR353JaMKSh89bk69zWmfgQSvvI0gJqRfAEnXLjrqqA+/RGkcR0hS3RsYpnxQqTasPqgJn8NwhoJJezUZ5YivKV5nriuYAP0Vbmo2NhH3CZN6AFwMsgb1gRy4S0fgCx5AGQJvaA6+hoi2jxs2NtidVJdNexR5swxe4oxKLI12qqvOAFJVAtwErkDvzUxZRp8Vu28AwAQkfm8uIpm/Ji6a2j76oLFlYmXrii3UXVIuHvDQ33mU3DyOMgS+1g/MQQ4FYHZqwP+008/4aWXXvJ024iXcACaRcV76QZU4Clb1VgYEffSrb1gUH3AerGs8vU9hFJtldajgvUB492fxBcKNBe+B1BTFcVRfMUxh/cVc3UDjGUedNX28dDm/YKytW0BMGjzfgHTq1BtSF0xjkDbPJax4ophYENfsgdV/z0EAFAetl2cwDT4BoTl2Kv+vVk4Xp4wSVZ95mNU7ZgIbcF6u+dm2groa3s9DJU7alYwFII8Y94y01VCaygnV7F5gEW9d+IO0yXslTlzwGuugumqhf/aDLbr/53byq3DULYqDbqC9WYpU57EdNU+X7nUWVQHPARpeR6P7VgFLR+cf+iuppaU/d7ckCPuuRJPwUJz7iu7P6vYdK1h5cE/fdgi77NcFZLYZizLp734i59b4numC74YMZ1QZpFpSoRJjNpyaM4sAQCojr4GpqusKe0IQH3qA2GSmeqyYYth4SJtGbQXfxHLNtoOtizOraqpWFO9d5rNfVSnPhT2BYPu6j7oincJFwxOjJxqDEuP6wyT8HRF/6Jq+23QXrYO8qv++x8YY9BXnXMqlUhEdx9F6tMfoWrnZJT92RXl6zJtz3Oo5yk71XumQl9+2Gwb01Wj+pDnKugxvRpla1qh2nCBGaioDngIkkskeOeaGyAP0jrgprP8XVG2pg1KVzZyqeJBfVa1awpKVzZC9YGnHAoWAh6j2fbEdcYUFV2xsFKo8S6S7srfQj4rrEfQAVgtg64+L9xh0BdvrzsPuJa0QH25MMKtMuaOMx6qo29AdeoDwx5OBOCGCwqTEwMwndTIUPHPTdCVHjRMvmVQHX3dbDTXYfXhs8ST9BrAcJGnK9mBqv+mofrgswCEGvumlVVCBdNVQHN2KXjVFZT90cVsnlL1/icdPw7jobn4m3g3SFdkvYhTIHEqBxwQ6oDr9daT94x1wLXa0JjgFcwYgEJlJZpExQVlGoonavcCNUsMy1KGIarXF/U2T5zXOjcZUXPuW2jOCUtHx408DU4W6Y1m+UBwXmAS/1IemmX2WGWYoKkvs07LMFYSMWf4HBE/T4T/ai6vhebMEoS3mW7/5IaLRu0V6+oeWsOotWk7dUXbIEuxXnbcWcyQoqI+U3MXW1+8HZV/DQcAaM4uhWmArz6zBPLGY8HJo8FJFW6fP5SYjv5qLv4GffF2SKJbgTEGXekBn+VmBxJjupW2YD2YugDay+sQ1thwkXv+O0R2sbF6pw36kl2o/u9BhLUIjLr8daE64CFIz3gsOb4L+iCtEqLxcM6YruBPMU+cVzowSSbIaJzM7TVVtqYVSlc2gvrslx5skY/Uz+sp4muGz0m+ynyyqebS77b3t5h7YFw0xjjqrD5b999j1fZbrQ9becri8Wmz9tlaWMlRlhcSlX+PMXusPPyC4V+csNT94edR+fdoqHMd+FyopwMbnqA3VADhK09De2kVEOA5y95iXBxMe3ktAICpS+yWx9SVHrB7h5YZyn86MjE8EFAd8BAkl0gxp/swyCXBWSWCeWD5aHvK13cTFvj5owuYZdm1IKU6/aHbx1AemonSlY2EixRVQd1PCAg0Ak48wPBlz7SlZpu1+WtrfZq+3M6qoh6bgyK0y3i73VN3Bu2fTqh3XrVjouGhFmBC/q728h92n0bht2Oq/3sAVbvu9Hcz/EJruHjUFWwAAKgN31nGuRbVh58XJ1RW/nU9lAeesjqGrng7qnbfbXacQEd1wEOQnvHYWXg+aEfAfYGpC1C2Kk3IiTZbvCMIeXjSafmfXcRg3BPLhXtNPS+zSXzFfLSt+tBzAAB9HUu6650s6+gsY5UfpvTNd642/3fw1eehu7LFcN5LUB2ZA335UVTtuguqk++Lo5bGuwP2FgwipDbGEWxxrsWZJShb3QJMK9Sv15z/DhV/jxVXv2a8DpX/3OSfxrrBqW8o0zrgS5cuxf79+7FmzRrMmGFd4owELp4x7C++BJ4+GB2iObNEDDiVR9/0d3MCStnq9OAIxglxEV91xuwxUxnS1Pw8ydeTK4U6ypgqYAtvuBBgTI/qPfcDEBYMYtoSn7SN1H9CeVCBvmQX9BXHwXgtyn5v6sdWuc6pSZj26oBfd911UCgUSE1N9XgDiefJJVI80L63v5sRlNQn34P65HsAAGmDHojuuwKcxOm5zPVS2ep08d+xw/ZBEuHvzwO6wCTe4241pvpGk/uF8F/DBO6acq90J4p4R9XOyZBENvd3M1xGdcBDkJ7n8WtuDvRBWgc8UOiv7kHZ703FEWB9hXVN4VBV/mdXsV9Upz/2SxuMNY4JId5T+fcos8fGyaBla9oIGygVjHhRsEy4tIXqgIcoCc1M97iKzf3FoLNsfU8xXy3UqXJeEvuF6q8TUs9ZpDayaooLCLGF6oCHIKlEgjHNM/3djHqNKfPM8tW4sATEDP4bkjDbJTxDibH+ulF0v5WQJfT0U2sIIZ6kL9lp9thYmYIQYs7pADw2Ntbuz1JSUtxqDPENLa/Hp8d24f52vYK2FGGwYZoSlK8zv+iJ7PkZwhqN8FOLAodlzeGw9ClQdJgDThrupxYRQggh3uV0AH7ixAnMmTMHFRUVmDhxIiZMmCD+bNmyZTh+/Diefz7Iy7bVcxKOQ6+kppSG4mfVu+9BtcW2qGt/hrzhtX5pT6DQ5H4JjcUCH+FtpiMi4wlwkjA/tYoQQgjxHKcCcGMd8LZt2yI9PR0PPPAAduzYgQULFgCgOuDBQspJ0COJViwNRFX/3my1Td7kJig6vw6JPM4PLQoMptVnjLiwhoju8wOkcR3sPIsQQggJTE4F4KZ1wAFg9uzZGD58OMLDwzF37lyvNJB4npbX4+W9G/BCtyGUghIEtBd/gfbiL1bbJbGZ4JrOBmPJ4ELwbgbTFKFi6xCbP4vs7v7qn4QQQoi3UB3wECTlJHiwfW9IqTxUUOPLjyA8ZyLKc2z8UBaNyK4LIUvo5fN2BYLq//7n7yYQQgghdjkVgHfp0gVvv/222TZjHfDrrrsOycnJ6NmTqhkEOg5AQngkQm/MNIToKlG9+x5/t4IQQgghNlAd8BCk5Xk8s2sNtEG4EA/TK/3dBEIIIYQQtzidg/Dzzz+jW7duVtuNdcBnz57tkYZZWrhwIdLT0xEdHY2hQ4fi5EladdBVcokE7/UZA7kk+FJQeCVN8iWEEEJIcHM6AouNjUWDBrYXE0lJSUFamuerayxbtgyzZ8/GJ598glOnTqFZs2YYOXIkLfrjIgbgbEUJWJ17BiKaNEoIIYSQ4BYUQ6AfffQR7rrrLgwbNgypqal49913ceHCBaxfv97fTQtKesbjh9MHoGfBmIJS5e8mEEIIIYS4xemFePxh3759uOeemgllsbGxyMjIwP79+zFypPmy1lqtFjqdTnysVAo5w4wxMObbMV9d+XFICjdDrYqFWCXOoTZY72O77ZbbHNlHaMOTcYA+Nxd6Z47lcP9Z7OdQ2wHGeEgrK6GqiDYpq2e+n+bcdw62gRBCCCGhzB+xn6PnC4oAvLy8HHFx5ouQxMfHo7y83Grf1157DXPmzLHaXlBQAIVC4bU22qSqQrUmEkwVDs6s5ohF/RGbNZwdqVHiynE48Ixhn4qhawQHCcfZCIVtHMfq2J5vMwNDJauEHjF2+0vSYATkVe87cB5CCCGEhLLS0lIA8OlaGcaB37oERQAeExODsrIys22lpaWIiYmx2nfWrFmYMWOG+FipVCIxMREpKSk+D8AZS0ZBeGMkpaQE1EIpOp5H/qm9GNK6G2QBNBGTMQZWUIDkWvpLVxyNqjwKwAkhhBBSu/j4eKT4OAbzaAD++eef4/HHH3fogPfccw/mz5/v0L6OysrKwn///YfJkycDACorK3Hy5ElkZWVZ7SuXyyGXy622cxznlyDYeN5ACsDlUinuyQjMeu119RcnjfBxiwghhBASjPwRgzl6LocC8BEjRqBNmzZm255++mk0a9YMEydORFhYGNavX4/ly5fjvvvuc761dZg6dSoeeughjBs3DllZWXj22WeRkpKCoUOHevxcoUDH8/gl9zBuSu8YUCPgjuBkPk4jIoQQQgjxMIcC8NTUVLNl5nfv3g0A+PHHH8VtI0aMQGVlJf755x9kZmZ6tJGTJk1CXl4exo8fj5KSElxzzTVYvXo1wsPDPXqeUMEBiJWHB+dKmBIKwAkhhBAS3FzKAT9x4gSaN29utb1ly5Y4ceKE242yZcaMGWa53cR1UokE1zfN8HczXCIJT/R3EwghhBBC3OJS/kGnTp2wdu1a7Nq1S9x27tw5LFmyBF26dPFU24iXaHk93jv8N7S8vu6dAwwni/J3E4JCRLuZiBtxAjHZ2/3dFEIIIYRYcGkEvHPnzpg5cyb69euH5s2bIywsDCdPnsTEiRMxceJET7eReJiUk2Bgo1aQcsGV/03MKbosxFX5tUhJbWx30ockBCetcuHJiOr1BSq3jax7Z0IIIcQPXC5D+Oyzz+L222/Hzp07odVq0aVLF3Ts2NGTbSNeIuE4ZCU28ncziIOi+/4GaUJPqyCbMQYUFNT6XE5iXRGovpAlDYSi81xIo5r5uymEEEKIU9yqA56eno7w8HAwxtC4cWNPtYl4mUavx/P//YFXug9HmFTq7+YQA3mjkYjs+h44WbS/mxJwFJ3eRFj6ZHAcvV8JIYQEP5cD8D///BNTp07FuXPn8MADD+Dpp5/Ggw8+iD/++AOSICttF2pkEgme6tQ/6EoQ1ieSyHRED1gHiTyu7p1DTFiLe6HoOIeCbUIIIfWWSwH45cuXMXHiRCxevBj5+fk4evQoWrVqhYSEBPz8888YP368p9tJPIgDECaVBmcZwiAV0X42wltPC6gFmQJFdL+VkCUE5sJQhBBCiDe4NAT6999/Y+DAgbj11lvNanH36NED//77r8caR7xDy/OYs3cDtDzv76bUW4qseYgbfQnxY/IRPyYfEW0eouDbIGbgJrFf4sfkU/BNSD0iSxoIAOAiaJ4RIbVxaQRcJpNBr7cuYXf16lUkJye73SjiXWFSKeb3Hu3vZtQrkqiWiBm4AZyUFgqyFN72cSjaPePvZhBCfCCi7WOovLIF0rgO0KnyAUk4wKv93SxCAo5LI+C9e/fG1q1bsW3bNnFbbm4uvvzySwwZMsRjjSPewTOGo6WF4Bnzd1OCWmSPT8RR3Njsfyj4NhE7dK/YNxR8E1J/yRKvBQBE9f5W2GCYu8HJYgAA0rhOfmkXqX+4iMbCBR0gfr9AGgF5k3E2949oP8uXzXOaSyPgqampWLRoEUaMGAGpVAqO4/DFF19g1qxZ6NmTbicHOj3j8fu5o2jdKRESmujmlJgBGyGNy/R3MwJS7IhjNKmUkBAR1nwSNOe+RXibh6Er/hfy5MEAAC48CbKG/RDZZT7KLq4AaL0J4iFRPT+FNK4Tyn6vKT0bf8NZAEDpxRUAAElkc/DV5wAA4a0fqrNUrz+5XAVl0qRJyM7Oxvbt21FdXY2ePXuibdu2nmwb8RK5RIqnswb4uxlBI2bgZkhj2/m7GQEp9vqjkITF+7sZhPiMJDYTfPkRfzcD8rRboM37yefnlUQ2A199HjDcQZUnDzL/eXgSoq9dLraRKS/5vI2k/ghrNhFMr4Si/bOQRDYFYwzR/dda7RfZ/UPIU4aAk0VDW7ARCII5V27VAU9NTUXv3r2pDniQ0fM8tl4+gwGpLSGlUoQ2KTq9jvAWd/u7GQEpZvA/kEa39HczCPEpWcProCvaBmlMu4AIwOGnOlaKTq+jaudk+zuYBD5R3RahcvttPmgVqW+irvkGsobXApIws5K0HMdBFt/Fav+wJjeK/5anZAMwLFYXwFyOvv7880+kp6ejcePGePnll3H69GkMHToUPFXWCHgMwKWqcgT2W9M/4kZdQPyY/HoVfEd2ec/tY8hShok5dxR8k1AiiW4DAJA26AIACG9xl0vHkSb29lCLbJMl9Xf5uREZT9vcLm96q/VGQ4AtiWoJGPK8ZYZR8Njrj1rPheHq72q8rgpLv8vm9ujr1vi2IQFEljIEiqy3AQARmS9AnpINTqqo1+tBuBSAG+uAv/XWW1iwYAEAmNUBJ4FNJpFgcptuQbsQT3jbJzx6vKhrvhaDS07i1k2hgCRv6npd/tihexA/Jh/R13zpwRb5hr2JOYQ4QxrTxvAvidl/I3sudfAAQkAqjRZSNGt7Xyo6vmr3Z7KGfQ3HixL+a3mL3Y3RPplFGklk9w8Np5AirNlEkx1jYBx5j2jzEOJHngAARPf+DgBsp6PVw89Ud0V2fgMAEDfyJAAgdth+w09CbFjMcAEHAFG9vkR488ngIhpDnjLYj43yHaoDHoJ0PI9vTu6FLkjvVoTZGpVxQeyIY4gfkw95Sv2u3ONK/fG40RcRPyYfEkUTL7TINzhphL+bQIJY7LADAEyDUyE4ksZ3Njy2/XcVniFU/YkbeQoAEN3vNwBAWPPbAQCR3d6v5azCOWIG/WX9IzsjyXE3nKnleK4Ja3Kj8HszBkXHOYbTx0OR+TxkDXog6ppvHD5WfR7BdFaERUUoThYNAJBEpAiPw5N83iZ/Ml7ARXb7AMa/p7hh/0Eak+HHVvmOSwE41QEPbhyAxlGxQbsSpjSquVvPN6aZUMUOc/Im42ruBNSDygWyhv383QQShORpNwOoCYY4WSwAIMy4XVITCMcMtjXgxAzPE0aqOS5M2Gwsz1fr35YhyBdH3U1YXEhzhk9wMeVDFlnLcc1FdhXS0sJbP+TA3kJ7YwZuQljT8eDkMWKOrUMoBUUU1sw6dz522D4AwqCHNLKpr5vkU5y8AbiwBPNtYQ0QlnZTSC5UR3XAQ5BUIsHgxq1DagKmJKqFuDJlfUwzqYssZajdnymy5iF+TD6iui/2YYt8gEbeiAsi2j4JoObOkbzR9Ygd+h+kMTVVvsJbPgBpTBtIo1vUfUBDYMxxcsgbWy+AFtZ0AgBDjjhn/7OJs0o9MQ9YJGGJdbel5mgO7saBk0UibvRFSBSNXLurJAndANyYbhSR8ZTdfSQRqQBqLswi2s3wfsP8JG7EEcRdnwNAqOMNAHHXB8KEZv9wKQIzrQM+Y8YM/PDDD2jXrh0efPBBqgMeBLS8Hm8f2Aotb30Xo76RRLcyLJTzb0heYRtFX/OV1TZFl3eFCafNJ9p4Rj1AAbhjDLfBQ500tqPwD4sRak4SBolCqPJlTEtRdHwJ0ujW5vtFGmsTm+fxSiObIqLdTEgUjRHV4xNxe3S/VYYnGnKq2z4BgAMX1kB4XoPu5g20DGTl0eBMgm6ZI6l0hgCaMwR9kqiW4rHD2z6GmOztNp/mzh0xWYNuLj83aHEySKJbiXn7Yc3vcPip4S3v81arRDEDN0ESk+G1u4Smiy/FDtsPWbJ5Treiy3yvnDfYuPxXNWnSJJw6dQpffPEFPvjgAxw8eBDPP/+8J9tGvETKSTCqeXtI60GagT2SyGZC4D34b383JWDEj8lH7PDDiBm4RQi8m03wd5O8iqtlNJHUiL7ma383AQDA+SUljENE5ovGf8LiH1YkEfZTLI0pKgAgsQjOI9pOByePNdsmS+ghPK+pRZk+Q/wec93vNXnoSQPFtQjkyUL6h6xBTzF9QXjcA1x4ck1QbUNEm+nCMZKuAwDx4psDB0W7GZBGpYv7RnZZ4JGVBOWpw90+RrAJb/UgOIkCvPIiAOF9o8h6G5CGARIhJclmnr+ws1faJIlpC2mccJEpjW2PqF5fiJNtPc7kol4SkYJo4yqpBuHNbvfOeYOM23XAx42jSgPBRsJxaB8f3Ln6scMPofwP20scx42+WC9ymL1BEp4IhDtzqzp4yVLtp92EIi48GUxdaOMngfG3IksaAO2llX5sgSGn2sU7ZfImN0N94l1DNRLHjyFLvAaQRoGTRkDaoAvCW94r/swY8Ed2WwRJeEPIEq6BLPEa6MoehjSqhZiPHndDLjhpOMKajIOuZKfVOWKH7Eb5Bvt3p42j7gAQM2SX2bndZbx7UF+FtbgXmrM1FXEksTUrJcuTBoJpywEA4c2F/O/4UcIqjTbz/AGvpUhKIpuDqfIR3vph4fwmF1sePU9sBygyX0DlthHWF5fEjMufvJ9//jm2bxduV33wwQeIi4vDmDFjoFarPdY44h0avR5P7FgFjY2JtMFCEt5QvI1qFDfyVL2ZQEjcR9UXzMkS7ARgLgacUX2WO7wv51AQ5v0SbGEt7rW5nYtoBKlhcQ9OkSamYkRf60RZXUM/SmPaQmYYYbY3ghyRaX63OO76w5A26AFZfBdEZDxp9rOo3t+JAbIs8Rrhv3EdxUmeAMBJjdXILIJ/w0gkM/StrWBYqHZUs72+TwT0NGNevLGWenjzSeLPZIm9ENnJfmlJT5JE1hQnsAx8o6/9GVG9voQkqqVYcUUki4W0gWdShzl5A8QO3CC8Xzk5IrsuEH9mzPkmNVyKVM6cOYO3334bPXv2hFqtxvz587F8+XLk5eVh+XLHP5SJf8glErzYbQjkQT4JM27YPsSNvojY648KgbfJFxIhxDapISc3ZvA/hi01AZs89XqHj8PJDSXUYjvY3UcSJUxSjOn7a90H9OCqdVy4EGRILVbMk0ZbjjrWTGiMzHoL0QP+BMdx4uigrOG1dZ7LOOIpUTSFuv3nkDcejchOrwEAIto8bPM5Ea2nAagJSjhphN2Rd3nyIOcuJk2OI43JQFjL+8S+NS3hGhvCk988SRqbCU6RJj6WJQu5+MzHNb2jen0BAIgddhCRXRcgqs9yxI3OQ8ygrZAm9gHHcYjq8bFVjnn8yONiaorTpJGQmaQYGf9epFHNETcq17VjhhCXIrDt27ejR48ekMlk2L17N0aOHIlhw4Zh0qRJOHDggKfbSDyMQRgFrw8l/zlOYnvxB0KIGVnyQOG/Da+DJDbTZEXTmoAtvNWDdp+v6PyW8N+OrwgbDB8gsQM32D+pC3chxOO7UHGDk8cDsA58a1YeZOaTFS2CXlmc7bS22sQM+FNIe5PIwGK6OP18zxJelJrVb5mhXGHNp70x511iknZC3GO8AxF3w1lIo5oZ3leuf8MaLyCdIY1tBy48BZIIoXymPKkfOE4KaUzbutOqnLgLpuj4ssnzDOkyshhEdl2EqJ5LTA4Z3AN8vuBSD0VHRyM3NxcAsG7dOlx7rXDVU1xcjISEhFqeSQKBjufxzqG/gnYhHkKI84w5qNaEQEGWOtwqrctUWDPhtrax8obEobkEhrxqhxZ0EtohbzzG8ND5AEbR6XWz8xr/q2j/nJjGYRx9BgB5k5sQ1mQsotyYjMZx0oAJNpghBSWsmXGkmwPAmY2gR7S2f5EVrCLazUTs8ENePQcX1hAAoOiyAAAQ3nKq4SfGtB8mpqPIEvu6t2CcAwGxMZ0qZsBGcUXNuOH7XT9nHYTFcgBOJkyWlsZ1QnTvb6DIeBpxQ/+DPI3mAzrLpWz/7OxsPPjgg+jcuTOKi4tx5MgR6HQ6rF69GsuWLfN0G4mHhUmlmNtrpL+bQQjxAWlcZ+jLDtZsMPlyjx1+CJw8DjEDN0Ea29728+O7QV+6F1Z1px3JFeaMExsdD1DFyX/MjQECy0Vr5MYl1GtypE1zUiWKRq6fK5BYTACN6vUFOEk4OHkM4kac8F+7vI5BEt4QER1egirnJY8eObzV/6A+/SEUnV9H9Z6pCGs8Gsr9jyGs+WSozxjLSnJgJheM8uQBkCcP8Gg7rBjnHMRl1rGjI4equ1Z7WNpNgDQCsvgsAEBk948dq4NP7HJ5BHzfvn2YNWsWtm/fjri4OFy8eBFz5sxBRkZoLCEazHjGcKA4H7wHcy4JqQ+My4cHK9MKDEYR7Z62v394Q3ASud3g25zwhS+JblXrXsYUElnitZC4cCu95nSuT6KV2FzKmhOCelmU10q9+VtYo5EIb3EPACB2xDHh9ZXHAID43/qkJsffe99lig4vAADCTBZRiuyxRKxiIonJcDvlxFKUjXUbLIU1Go3wlvd75HwR7Z4xmRMiCG/zqOG/08UFpMIajYTEcDcrFBe08zSX75ulpqbitttuQ7NmwuIDzZs3x4033uipdhEv0jMeW/JPQ+/OCBMhQcChUVoA8tQRwT2R17BcuqxBD4Q1v1PYZqg3bEmePAQRrR5w4uCGwMIw4iaL72xzL+MXtlFk98WQRKZBljTQsdNY9L3MiRFEY71sI84YYJuNhBvaH9cJcSOOOXzsYCJreC3CDKkAEr/UVfc+aXxXseKHosMcAIA87RbDTzlwcu/ntoc1vgEAEDfqPGRxHaFoP9ssQHeXrbkIxoWi+Mj2iOg0F7LEXub52G7gZJHiipzSOOHvW9H+WUT3XwdF+5lmC0gBQPR1axxMKyO1CYzENeJTcokU0zv2g1xCZdpI/RbjwEJMsSOOIarXZz5ojffUTLJitS57HTv8EGQJ3Z3MT7W99LklqeHWtPVzbY8MmpZNA4SFk0yrSSiMC+Q4wLJmtbGqQ3jzKRZ7Cm2pKdtHApXlRMSoa74x/Kvm/SSJTENYs4nmpRPtXHi60IK69zDUYZenDhUXSvKW6L6/IHbUhf+3d+dhUd3nHsC/58zOMIyALAIu4K6A4h1RH3dRbsQtLklTzWOIkhhvTM1TNeTG2t40CWli01xzG+PS6B+xBtOmLtFUYhJ9glVjFM2CSbVusYJEA4rBAYE594+BI8uwDAxzzjDfzz/O/ObMOS+vM/DOmff8frgbvx2GXq1fWbPVas5o67pNlYe0Lt/TgDY4STXXPfgyZtAPVTsc2H/ln6jmRZjUyQnN/DHWRkyBdcbVRmcKaxeq8C21xYIDgtYEwejsaTYNWQtt2HhYUo4BcLactP8YQNB93wJwLp5TS6yZgaRxwe26AG+4MmRDmsBYaMMmQBfzQKsj1AQn1QSjd86rHVl3xhNNk7GQ+mhq2ohq57QWLf1qHpGAmg9QoikKAUNfq/Msya0ZPURLg6JZRavn6qJmwJTwEnTdpkMTbIOgs3To2gaCqHeukNx3OazTLnXYcegeFuB+SAJQWlnBP0Xktwy9l8Js2+TyLI6+e+sLPqUZB2Tem7YPACQJgjYQ1tQ8GPuvgjYk2dnjbe7Z9E4aqP1qWdt1nHNAbHyBVu3Un4GjsuUxl3NmC8K9pdXHfyy3iogBPeRNAkf/DYDzDHptsaWTl3V3XVCZa5a21kXXn3mh7up+lrEfQNSHyAsGWcbvh77HApD3iYF92vxcU02BLQAIHL0bhrglCBy9E9ZpFz0UXVPatkCVp5htm+R+frGZ2Yk8TRAEfkPkJSzA/ZBWFPFgXCK0Pr4QD1FrBCS9Ue++MSELxkG/kqcMawsxoFc7o/IMTUgyUG8GgzrzPfddBo181rD1DL3SIZhioO/lbN/QBA2CLnp283MJ1zlzKM8GIWhRtwVFYx0st4roYxfB0Pepmp9hJABAGzoKpgHO9hnzsD82H6QbF5DrwsYAcBYxgjag1c8jz3F+sGpdQWsZ75xX3jhgVc2c5ff+TmlDk6GPmQ1RH9Ku92/Tmn9dBdg2t2l+eiJXWIH5oSqHA1v++QXnASe/oO/+ACwTD0Efuxjlw084C8xm+xebLxS0EZMROHavZ4NsJeNgV33RDZYfby9BRL1CfvBv6i0p7UqXGVcAAEFT8mDo+TCs069ANIRCDOgOscHZd23EFGitCfJFa3Jh70brwD1NFUz8fk9NjH2XIWjqt81uow2fBMD5QQ0AtCE2GPs8AUEQnK0iblwgHZR6us2xCjUtaZaUIwhKPeW8PfEQAEAfNd3rvc/GASubva6DfJd6Gp7IawQB6Gft2ra/d0Q+SGPpD1P8CygtKmpx26a+Lhd0wdBFz0JA4sueDq/1GtSVQp0bmmCbhy5AE5ytLIZQOAIGQhD1cpEclPpVs89sOJ+2scHMKAAQWGeKtdoCx5SQBdEY5WKPtSs5tp417TwvEFOhlmZlMfRegqofPgWARu0lQRMPtuoY2i5JQM+HIRpdT3/ZZWYhbu7pBlP8C7B/swb3ZvjRAlIVABGWlKOo+uHTem1bGpfTWnqHksemjsXfUn5II4gYExkLDf9IETXSVKuFKf5/vF58WyZ82mCkZtVKF1P7mYe/DeOATA8c1dk2og1Jxt347fUeqV3m2lNqe1sNsY820x7SdAFu6PVo463ZZqJarj7caiOds27owsbJY21tL9GGJsPYf0WL2+l7pcu3u8wsRJcZV2Aa+jog6iHqg6GXr0Eg6jiswPxQpaMaL536FJWOaqVDIVKlhstaW6ddavPS0tquY9seSBO9zrXLqtclGsMhuhh3m5q+GZPgojWlfk9wrYCk//NOTNRmQZNy682cA9SfmafRrCTtZEr4HYB7y7Y3VPcaCY01Hobej7vcjqgjsAXFD2kEEQ/1HsIz4ERNEA1does2HYY+SyGaYto0K4BgjIRUfg0a62BU3chtYySup/Qz9FmKyqs7AQDa8IkwtWt6wfr0MQ9A13Vcyxt6jQBd9BxUXv0boDHClPAy6ubFMsmZW333eU08n3xFa1tNWksXORn2r123cWjDxtW7eFhrjYe2Zv54Im9gBeaHBACxlhBVnegiUhvz8M3QBg9rtMhLa+nrrM7XVlITFxNqrQkwj9gGTZdEaMw9oY+a3uZjNCQaQqGxNl7SXjGCAFNCzVSLEgAIEM295bOamnZMcUcKqDnxY+jvbJcSPPjhsSna4GHybV3UTEDQwJTwOxgHPNvhxyZqCgtwP1TpcGD50T2o5CwoRB1GFz7RA3txFuBBU/Jq7t4ryHURKRC0gR44hpo5Z3gRtBYYB66GxtIXoj4EmsBYBCS8qHRw1CbOD6TGfstRGf0EDP1WNGr58pja94vWIg+ZbRshCAI0gbHQmHs08USijscC3A/pRBGvJqdBx3nAiTqO3LtcU3D0X+X+PmoKiIazi/gXAYKog7HvMljGfwRd5BSlA6J20HQZKt+ujl4CQRDbuUJrK47JQptUiBWYH5IAFFfc4Uy5RB1IvqCsLfN9akw1Nxp8SyX622U7/C3V2RjiMpQOgUgVWID7oWrJgQ3fHkO1xBYUoo7S6hlJXEy5Jk8/WKf+DJr6HQyxjafd6/x4tUpnIuqD0WVmodJhECnO306nEACdqMELtv9UOgwiP9FSAXnvcdEcB0fZBWjMvWpG7lXgtQuZiOY4z4anYsaB/w1B0/oVEImIfIVPFOC5ubnYvXu3fH/16tUIDvbAfLd+qlpy4NSNAiR1jeJUhERtpOkyFKI5Vp4O0BXjwF/BEPsIpOo7zeypmQLdxbdUQSn/cCNK31Z39goit3G5Z1Ixn6i+zGYzIiMjodFo8Nprr+HWrVtKh+TTHJKE49evwNHEIh9E1AqCDoI+pNlNjH2fhKANREDCS01uc2+6QqBxMc73KFFbCYYwBAx7U+kwiFzyiQJ82LBhWLlyJR591B/7Hz1PJ2rwX4NGQSdqlA6FyHcJgDsFsq6J5a2bWvZaGzbe5YqXRNSyoNQvIYh66GPm1Nw/rWxARA34RAuKOyorK1FVVSXft9vtAABJkiB5+Yxv7TG9fdyWVDsc2HflO0zrPgAaFU1FqNZ8qRXz5R7P50to1CJiGroO0t1ilJ95vtFxxIAegM4KY9+nUX7m+Xtx1azGJ1oGAo67cqzmke9CkhwISH5Hkf9jvr7cw3y5p6PzJRjC6u1bMIT7/P8NX2PuUSpfrT2eYgX4J598gr///e9NPp6UlIQFCxa4vd+XXnoJzz//fKPxoqIimEwmF8/oOJIk4ebNmwAAQUW9aNWSAz+VlaHohyJV9YCrNV9qxXy5x9P50ldWouKOXf4l6tBH4dYdAZJxGAxw/s5pyOAAbpfdha7OWHHJLWiiHoNYcgjVIVOgKzvf4LnxgIt9dTS+vtzDfLmH+XIfc+YepfJVe+K3JYoV4LV93U2xWq1t2u/q1auRmZkp37fb7QgNDUVERIQiBTgAREREqO7NMj9SfQt7qDlfasR8ucfT+XJY3gJEA24f2AEA6DLliLMvXBBw6yvncRoqFUVYgoJQXmcsNDQUDtNIVAfoYRy4GreubnD5XG/j68s9zJd7mC/3MWfuUSpfqi/AR44ciZEjR3p8vzqdDjqdrtG4IAiKvGBrj6umN0uloxpb/vkFFvUfrro+cDXmS82YL/d4Ml8ac0/5tr7HfIgag3w/cMxe18cQAKHhhZaCAH1UGhCVVi9ONeDryz3Ml3uYL/cxZ+5RIl+tPZZ6+g/Ia0RBwNDQKIh8AxN5hCn+hXr3tSH/4XrDmtZA86j3OjgiIiJSM5+4CPP8+fN46623UFxcDADIyspCUFAQfvGLX6BHjx4KR+d7NIKIEeHMG5EnaCMmQ9AGKB0GERH5EJ8owPV6PSIjIxEZGYm1a9fK465aTahllY5qvHjqE/wqKUV1LShEviZwxDvt3EP9b6KsaefbuT8iIlI7nyjAu3fvjpUrVyodRqehEURk9E9W1QwoROTEs+lERJ0fKzA/JAAINwU2twA2EREREXUQFuB+qNLhwMrP96HS4Wh5YyLqUI1mRSEiok7PJ1pQyLN0ooj/HTmDs6AQKUwXMw+CIVzpMIiIyMtYgPshCcD3ZTfRMzCY596IvEgwRUHQBUJjjUfAsD9CHzNX6ZCIiEgBbEHxQ9WSA9vO5aFaYgsKkTdZxn0IXfRsiPpgFt9ERH6MZ8D9kE7UYM2wyUqHQeR3BFGvdAhERKQCPAPuh6olB/5RdIlnwImIiIgUwALcDzkkCd+V/ACHJCkdChEREZHfYQuKH9KJGiwekKx0GERERER+qdMX4FLNWV673a7Ise12O+x2OwQVTflX5XBgz/dnMLPHIGhF9XwJotZ8qRXz5R7myz3Ml3uYL/cwX+5jztyjVL5q602phS6DTl+Al5eXAwBCQ0MVjoSIiIiI/EF5eTkCAgKafFyQWirRfZzD4cDNmzdhNBq9/onRbrcjNDQUP/74I0wmk1eP7YuYL/cwX+5hvtzDfLmH+XIP8+U+5sw9SuVLkiSUl5ejS5cuEJvpMuj0Z8BFUURISIiiMZhMJr5Z3MB8uYf5cg/z5R7myz3Ml3uYL/cxZ+5RIl/NnfmupZ4GYCIiIiIiP8ACnIiIiIjIi1iAdyCtVovf/OY30Go7faePRzBf7mG+3MN8uYf5cg/z5R7my33MmXvUnq9OfxEmEREREZGa8Aw4EREREZEXsQAnIiIiIvIiFuBERERERF6kzs70TqCsrAyHDx9GdXU1xowZg6CgIKVDUq28vDycPXsWgHPe9gcffFDhiNSvpKQEX3zxBfR6PWw2GwIDA5UOSdUqKipw4sQJ3L59G0OGDEG3bt2UDsknXLt2DYcOHUJSUhL69++vdDiqdOPGDXz88cf1xkJCQpCamqpQRL6hoqICx44dQ0VFBcaMGdOqeZP90YULF3D8+PFG49HR0Rg7dqwCEfmG8+fP48yZM7BYLEhOTlbl64sFeAc4c+YMJk+ejG7dukGv1+PcuXPYt28fRowYoXRoqvTll18iJycHBQUFOHLkCAvwFvz617/G1q1bMWjQIBQXF+PixYt49913MWXKFKVDU6UDBw5g2bJliIqKgkajwdGjR/Hb3/4WK1asUDo01XvkkUdw8OBBZGVlsQBvwnfffYeFCxdizpw58ljv3r1ZgDfj2LFjmDdvHkJDQ9GjRw+sWrUKO3fuRFxcnNKhqc7ly5exa9euemO7d+/GkiVLWIA34emnn8aWLVswfvx4XL16FQUFBdi/fz+GDh2qdGj1SeRx48ePlxYsWCDfX758uRQfH69gRL7hgw8+kDQajdJhqN7WrVslu90u3//lL38p9e7dW8GI1O3jjz+Wrl+/Lt/fuXOnJAiCVFxcrGBU6rd+/Xpp3rx50uDBg6W1a9cqHY5q5ebmSlarVekwfEZJSYkUFhZW7zV18eJF6cyZMwpG5Tu+/vprCYCUn5+vdCiqdO7cOQmA9Pnnn8tjc+fOle6//34Fo3KNPeAeVlxcjM8++wxLly6Vx5YuXYpvvvkG//rXvxSMjDqL9PR0GI1G+f6QIUNw48YNBSNSt5SUFHTt2lW+36dPH0iShLKyMgWjUrcLFy7glVdewZtvvql0KD7B4XAgJycHOTk5KCwsVDocVcvOzobRaERGRgb27t2Lw4cPo1u3bhg4cKDSofmEDRs2YOzYsRg0aJDSoajS3bt3AQA9e/aUx3r16iWPqwlbUDzs4sWLkCSp3ldpsbGxAJx/1Pr06aNUaNQJVVZWYuPGjfW+/qbGSkpKkJOTg5KSEvzpT3/Cs88+i5iYGKXDUiWHw4H09HRkZWUhPDxc6XBULywsDGlpadi6dSsKCwtx/PhxPPfcc1izZo3SoanS6dOnERQUhFGjRiEuLg6XLl3C3bt3kZOTwxaUFty5cwfbtm3D+vXrlQ5FtQYNGoSnnnoKP/vZz7Bw4UIUFBRg9+7dyM7OVjq0RliAe1hVVRUAQK/Xy2NarRaiKMqPEXlCdXU10tPTYbfbsW7dOqXDUbWSkhLs2rULJSUlKCkpQVhYmNIhqdbrr7+OLl26YP78+UqH4hP69+9f7497bm4uJk2ahEmTJmH06NEKRqZOFRUVyM/Px7FjxzBixAg4HA6kpaUhMzMTf/nLX5QOT9W2b98OnU6HuXPnKh2KqnXr1g05OTnYtWsXrl+/Ll+PpzZsQfGwiIgIAM7ZA2pdv34dDodDfoyovSorK/Hzn/8c58+fxyeffAKLxaJ0SKoWFxeH7Oxs5OTk4MCBA8jMzMTBgweVDkt1SktLsWbNGkyYMAHZ2dnIzs7GrVu3cPr0aeTk5Cgdnk8YO3Ys+vXrh88//1zpUFQpIiICYWFh8qQEoigiLS0Np0+fVjYwH7Bhwwakp6fDYDAoHYpq7dy5Ey+//DJyc3OxZ88eHD16FCkpKZg3b57SoTXCAtzDevXqhZ49e2Lfvn3y2N69exEcHIyEhAQFI6POory8HPfffz+Kiopw4MABBAcHKx2SqhUVFdW7Hx0dDYPBgJs3byoTkIpJkoSZM2fi+PHj2LVrF3bt2oXbt28jPz+fH1ia0PD1VVxcjCtXrrDFqQkTJ05ESUkJfvzxR3ns3LlziI6OVjAq9Tt58iTy8vKwZMkSpUNRtcLCQgQFBTW67qfuSVG1ECRJkpQOorPZvn07Fi9ejOeeew4GgwEvvvgisrKysGzZMqVDU6XaeU5PnTqF3//+9/jzn/8MAJgzZ44qvzZSWmpqKvLy8rB27VqYTCZ5fO7cudDpdApGpk7Tpk1DbGwskpKSUFZWhm3btsFut+PIkSP85qAV4uPjkZ6ejpUrVyodiiplZmbi4sWLmDhxIioqKrB582aYzWYcPnyYv79ckCQJqampKC0tRUZGBi5cuIB169Zhz549mDx5stLhqVZGRgYuX76MAwcOKB2Kql25cgVDhw7F2LFjMWvWLFy/fh1/+MMf8OCDD+KNN95QOrx6WIB3kE8//RQ7duyAw+HArFmzMH36dKVDUq2DBw9i48aNjcY3b97MAsmF9PR0lJeXNxrfsmWLKhcbUFpVVRW2bduGI0eOwGAwICkpCQ899BBz1UqrVq3C+PHj+TusGXv37sX+/fshCAKGDRuGBQsWsPhuRu0HlRMnTiA8PBwPP/wwEhMTlQ5LtSRJwmOPPYb58+dj0qRJSoejelevXsXWrVtx4cIFmM1mTJgwAbNnz4YoqqvpgwU4EREREZEXqevjABERERFRJ8cCnIiIiIjIi1iAExERERF5EQtwIiIiIiIvYgFORERERORFLMCJiIiIiLyIBTgRERERkRexACcionbLzs5GVlZWi9vZ7Xakpqbi1q1bXoiKiEidWIATEXUS1dXVsNlsuHz5slePW1FRgWeeeQazZs1qcVuTyYRBgwbhlVde8UJkRETqxAKciMgH3b17FzabDf/+97/lMY1Ggw0bNiAiIsKrsbz//vuIjo7G4MGDW7X9okWLsHHjRlRUVHRwZERE6sQCnIjIBzkcDpw8eRLl5eX1xm02G4xGo1djyc7OxsyZM1u9fWJiIiwWCz766KMOjIqISL1YgBMR+aDZs2fL/9psNqxbt65RC4rdbofNZsOHH36IRx99FOPGjcMzzzyD8vJybNq0CZMnT8a0adNw6NChevsuLy9HVlYWpk6dihkzZmDr1q3NxnL48GHYbLZ6Y2+//TamTZuGyZMn49VXX0VVVVW9x4cPH47c3Nx2ZoGIyDcJkiRJSgdBRETuOXHiBIYPH46dO3ciJiYGkZGRiIyMhE6nw7fffosBAwbgp59+gsViweDBg/HCCy9Ar9fjiSeegMViwZgxYzB//nwcPnwYr776Ki5duoSQkBBIkoRx48YhMDAQTz/9NMrLy5GZmYnFixdj1apVjeIoLS2F1WrFN998I7eg7N69GxkZGXjzzTcRHh6Ojz76CFarFZmZmfLzli9fjmvXrmHHjh1eyxkRkVpolQ6AiIjcFx8fL//bp08fAGh0lrnWunXrkJKSAgBIT0/Hjh07sHHjRgiCgAkTJmD9+vU4efIkpkyZgg8//BBnz57F999/D4PBAACwWq146KGHXBbgtX3cer1eHisoKMCAAQPwwAMPyMdo2O9tMBjYA05EfosFOBFRJ9e7d2/5ttVqRVxcHARBkMeCgoLkaQHz8/Nx584djB49Wn68srISRUVFuH37NiwWS719h4SEQKPRoLi4WB5buHAhjhw5gsTERIwaNQopKSmYN29evecVFxcjLCzMoz8nEZGvYAFOROSD6hbQnhQSEoKYmBhs2LCh0WMmk6nRmEajwZAhQ5Cfn48RI0YAAMxmM9555x1UVlbi1KlTeP7557F7925s375dft5XX32FRYsWdcjPQESkdrwIk4jIBxkMBgQEBOD69ese3e/UqVNRVFSEy5cvw2azwWazoXv37vjss8+g1bo+Z9PwQs733nsPeXl50Ol0SE5OxpQpU/Dll1/Kj9+8eRNff/017rvvPo/GTkTkK3gGnIjIR2VkZCAtLQ1xcXFYuHAhnnzyyXbvMzo6Gn/961+xZMkSLF++HAEBAbDb7Vi7dm2Tz1m0aBGGDRuGsrIymM1m9OvXD48//jgKCgpgNptRUlKCTZs2ydu///77mDBhAnr16tXueImIfBFnQSEi8mGFhYUoLCxEeHg4YmJicOLECcTHx8NoNMLhcCAvLw+JiYnyRZJFRUUoLS1F37595X3k5+cjKioKwcHB9fZdUFAAu93eqGfclccffxz9+/fHihUr5LGrV6+irKwMsbGx0Ol0AJzzlycmJmLLli1ITk72VBqIiHwKC3AiImq30tJSXLt2Df369Wt2u4qKCpw9exYJCQleioyISH1YgBMREREReREvwiQiIiIi8iIW4EREREREXsQCnIiIiIjIi1iAExERERF5EQtwIiIiIiIvYgFORERERORFLMCJiIiIiLyIBTgRERERkRexACciIiIi8iIW4EREREREXvT/iQQUY0H193EAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def render_idle(seed, seconds=8.0):\n", + " g = tap.Garden(sr, smooth_ms=0, idle_seconds=0.5, loop_seconds=1.0,\n", + " seed=seed, bell=(0.01, 0.6, 0.8), decay=0.7)\n", + " return g.process(int(seconds * sr))\n", + "\n", + "a = render_idle(1111)\n", + "b = render_idle(1111)\n", + "c = render_idle(2222)\n", + "print(\"same seed bit-exact:\", bool(np.all(a == b)),\n", + " \" different seed differs:\", bool(np.any(a != c)))\n", + "\n", + "t = np.arange(a.size) / sr\n", + "fig, axes = plt.subplots(2, 1, figsize=(9, 4.2), sharex=True)\n", + "for ax, y, seed, color in [(axes[0], a, 1111, C[0]), (axes[1], c, 2222, C[1])]:\n", + " ax.plot(t, y, color=color, lw=0.5)\n", + " ax.axvline(0.5, color=C[3], ls=\":\", lw=0.8)\n", + " ax.set_ylabel(f\"seed {seed}\")\n", + "axes[1].set_xlabel(\"time (s)\")\n", + "axes[0].set_title(\"two gardeners: patient to the idle threshold (dotted), then their own gardens\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b6ed0434", + "metadata": {}, + "source": [ + "## 5 · An hour of garden, in two minutes\n", + "\n", + "A handful of hand-planted notes to start, then the gardener takes over: `decay` 0.85 and\n", + "`soften` 0.9 keep each bloom returning for a dozen passes, softening as it goes; the\n", + "population breathes around its converged size instead of piling up. This render would go on\n", + "— unrepeating, bounded, self-tending — for exactly as long as you let it." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6de300a2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T01:40:39.866122Z", + "iopub.status.busy": "2026-08-12T01:40:39.865857Z", + "iopub.status.idle": "2026-08-12T01:40:46.003609Z", + "shell.execute_reply": "2026-08-12T01:40:46.002440Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "live events at the end: 20 ringing bells: 16\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Audio\n", + "\n", + "g = tap.Garden(sr, smooth_ms=0, loop_seconds=6.0, decay=0.85, soften=0.9, floor=0.02,\n", + " bell=(0.12, 3.0, 0.9), scale=3, root=9, idle_seconds=4.0, seed=2008,\n", + " level=0.35)\n", + "\n", + "chunks = []\n", + "plants = [(0.0, 69, 0.7), (1.2, 76, 0.55), (2.6, 64, 0.6), (4.0, 81, 0.4)]\n", + "cursor = 0.0\n", + "for when, pitch, vel in plants:\n", + " n = int((when - cursor) * sr)\n", + " if n > 0:\n", + " chunks.append(g.process(n))\n", + " g.note(pitch, vel)\n", + " cursor = when\n", + "chunks.append(g.process(int((120.0 - cursor) * sr)))\n", + "y = np.concatenate(chunks)\n", + "\n", + "win = int(2.0 * sr)\n", + "frames = y[: y.size // win * win].reshape(-1, win)\n", + "fig, ax = plt.subplots(figsize=(9, 2.4))\n", + "ax.plot((np.arange(frames.shape[0]) + 0.5) * 2.0, np.sqrt((frames ** 2).mean(axis=1)),\n", + " color=C[0])\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"RMS\")\n", + "ax.set_title(\"four planted notes, then the gardener: the population breathes, bounded\")\n", + "plt.show()\n", + "print(\"live events at the end:\", g.active_events, \" ringing bells:\", g.active_voices)\n", + "\n", + "# Preview: first 60 s, embedded at 16 kHz to keep the executed notebook small (the bells\n", + "# live below 4 kHz); tools/render writes the full-rate, full-length WAVs.\n", + "Audio(np.clip(y[: int(60 * sr) : 3], -1, 1), rate=int(sr / 3))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/taptools_py.py b/notebooks/taptools_py.py index 1cc841e..85e4d3e 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -16,9 +16,10 @@ tap.303.seq~ (`TriggerRow`, `NoteRow`), tap.808.kick~ (`Kick`), tap.delay~ (`Delay`), tap.multitap~ (`Multitap`), the Discreet Music two-machine tape loop tap.discreet~ (`Discreet`), the Music for Airports -incommensurate loop bank tap.airport~ (`Airport`), and tap.tune~'s pitch -corrector (`Tune`, with the shared DspTap detector passed through as `Yin` -for the notebooks' pitch tracking). Parameter names on the +incommensurate loop bank tap.airport~ (`Airport`), the generative event +loop tap.garden~ (`Garden`), and tap.tune~'s pitch corrector (`Tune`, with +the shared DspTap detector passed through as `Yin` for the notebooks' +pitch tracking). Parameter names on the kernel classes mirror each kernel header's param_index enum. Copyright 2003-2026 Timothy Place. MIT License. @@ -292,6 +293,26 @@ def load() -> ctypes.CDLL: "taptools_airport_phase": ([vp, ctypes.c_int], ctypes.c_double), "taptools_airport_composite_period_seconds": ([vp], ctypes.c_double), "taptools_airport_process": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_garden_create": ([], vp), + "taptools_garden_destroy": ([vp], None), + "taptools_garden_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_garden_note": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_garden_set_loop_seconds": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_garden_set_decay": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_garden_set_soften": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_garden_set_floor": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_garden_set_bell": ([vp, ctypes.c_double, ctypes.c_double, ctypes.c_double], + ctypes.c_int), + "taptools_garden_set_root": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_garden_set_scale": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_garden_set_idle_seconds": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_garden_set_seed": ([vp, ctypes.c_ulonglong], ctypes.c_int), + "taptools_garden_set_level": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_garden_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_garden_clear": ([vp], ctypes.c_int), + "taptools_garden_active_events": ([vp], ctypes.c_int), + "taptools_garden_active_voices": ([vp], ctypes.c_int), + "taptools_garden_process": ([vp, f64p, ctypes.c_int], ctypes.c_int), "taptools_yin_create": ([ctypes.c_int, ctypes.c_int, ctypes.c_int], vp), "taptools_yin_destroy": ([vp], None), "taptools_yin_frame_size": ([vp], ctypes.c_int), @@ -1225,6 +1246,83 @@ def __del__(self): self._h = None +class Garden: + """tap.garden~'s kernel (tap::tools::garden::bed): a generative event + loop on the Bloom principle. Planted notes snap to the scale, bloom on a + two-operator FM bell, and return every loop pass a step quieter (decay) + and purer (soften) until they retire below the floor; left idle, a + seeded gardener plants for you. Scales: 0 chromatic, 1 major, 2 minor, + 3 major pentatonic, 4 minor pentatonic.""" + + def __init__(self, sr: float = 48000.0, **params): + self._h = _LIB.taptools_garden_create() + _check(_LIB.taptools_garden_prepare(self._h, float(sr)), "prepare") + self.set(**params) + + def set(self, *, loop_seconds=None, decay=None, soften=None, floor=None, bell=None, + root=None, scale=None, idle_seconds=None, seed=None, level=None, + smooth_ms=None) -> "Garden": + """`bell` takes an (attack_s, decay_s, brightness) triple.""" + # configuration first, so ramped targets in the same call honor the new slew + if smooth_ms is not None: + _check(_LIB.taptools_garden_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + if seed is not None: + _check(_LIB.taptools_garden_set_seed(self._h, int(seed)), "seed") + if root is not None: + _check(_LIB.taptools_garden_set_root(self._h, int(root)), "root") + if scale is not None: + _check(_LIB.taptools_garden_set_scale(self._h, int(scale)), "scale") + if bell is not None: + attack_s, decay_s, brightness = bell + _check(_LIB.taptools_garden_set_bell(self._h, float(attack_s), float(decay_s), + float(brightness)), "bell") + if loop_seconds is not None: + _check(_LIB.taptools_garden_set_loop_seconds(self._h, float(loop_seconds)), + "loop_seconds") + if decay is not None: + _check(_LIB.taptools_garden_set_decay(self._h, float(decay)), "decay") + if soften is not None: + _check(_LIB.taptools_garden_set_soften(self._h, float(soften)), "soften") + if floor is not None: + _check(_LIB.taptools_garden_set_floor(self._h, float(floor)), "floor") + if idle_seconds is not None: + _check(_LIB.taptools_garden_set_idle_seconds(self._h, float(idle_seconds)), + "idle_seconds") + if level is not None: + _check(_LIB.taptools_garden_set_level(self._h, float(level)), "level") + return self + + def note(self, pitch: float, velocity: float) -> "Garden": + """Plant: MIDI pitch (fractional ok, snaps to root/scale at entry), + velocity (0, 1]. Sounds on the next processed sample.""" + _check(_LIB.taptools_garden_note(self._h, float(pitch), float(velocity)), "note") + return self + + @property + def active_events(self) -> int: + return int(_LIB.taptools_garden_active_events(self._h)) + + @property + def active_voices(self) -> int: + return int(_LIB.taptools_garden_active_voices(self._h)) + + def process(self, n: int) -> np.ndarray: + """Render n samples (a source: no input).""" + out = np.zeros(int(n)) + _check(_LIB.taptools_garden_process(self._h, _p64(out), out.size), "process") + return out + + def clear(self) -> None: + """Uproot everything; parameters are untouched.""" + _check(_LIB.taptools_garden_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_garden_destroy(h) + self._h = None + + class Yin: """The shared DspTap pitch detector (tap::dsp::yin), passed through the C ABI so the notebooks can track pitch with the same detector the corrector uses.""" diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index adc1edf..2c6f165 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -1211,4 +1212,93 @@ int taptools_airport_process(taptools_airport h, const double* in, double* outL, return with(h, [&](airport_bank& b) { b.process(in, outL, outR, static_cast(n)); }); } +// ---- tap.garden~ --------------------------------------------------------------------------------- + +using garden_bed = tap::tools::garden::bed; + +taptools_garden taptools_garden_create(void) { + return static_cast(new garden_bed()); +} + +void taptools_garden_destroy(taptools_garden h) { + delete static_cast(h); +} + +int taptools_garden_prepare(taptools_garden h, double sr) { + return with(h, [&](garden_bed& g) { g.prepare(sr); }); +} + +int taptools_garden_note(taptools_garden h, double pitch, double velocity) { + return with(h, [&](garden_bed& g) { g.note(pitch, velocity); }); +} + +int taptools_garden_set_loop_seconds(taptools_garden h, double s) { + return with(h, [&](garden_bed& g) { g.set_loop_seconds(s); }); +} + +int taptools_garden_set_decay(taptools_garden h, double per_pass) { + return with(h, [&](garden_bed& g) { g.set_decay(per_pass); }); +} + +int taptools_garden_set_soften(taptools_garden h, double per_pass) { + return with(h, [&](garden_bed& g) { g.set_soften(per_pass); }); +} + +int taptools_garden_set_floor(taptools_garden h, double v) { + return with(h, [&](garden_bed& g) { g.set_floor(v); }); +} + +int taptools_garden_set_bell(taptools_garden h, double attack_s, double decay_s, double brightness) { + return with(h, [&](garden_bed& g) { g.set_bell(attack_s, decay_s, brightness); }); +} + +int taptools_garden_set_root(taptools_garden h, int semitone) { + return with(h, [&](garden_bed& g) { g.set_root(semitone); }); +} + +int taptools_garden_set_scale(taptools_garden h, int scale) { + return with(h, [&](garden_bed& g) { g.set_scale(scale); }); +} + +int taptools_garden_set_idle_seconds(taptools_garden h, double s) { + return with(h, [&](garden_bed& g) { g.set_idle_seconds(s); }); +} + +int taptools_garden_set_seed(taptools_garden h, unsigned long long seed) { + return with(h, [&](garden_bed& g) { g.set_seed(static_cast(seed)); }); +} + +int taptools_garden_set_level(taptools_garden h, double lin) { + return with(h, [&](garden_bed& g) { g.set_level(lin); }); +} + +int taptools_garden_set_smooth_ms(taptools_garden h, double ms) { + return with(h, [&](garden_bed& g) { g.set_smooth_ms(ms); }); +} + +int taptools_garden_clear(taptools_garden h) { + return with(h, [&](garden_bed& g) { g.clear(); }); +} + +int taptools_garden_active_events(taptools_garden h) { + if (!h) { + return -1; + } + return static_cast(h)->active_events(); +} + +int taptools_garden_active_voices(taptools_garden h) { + if (!h) { + return -1; + } + return static_cast(h)->active_voices(); +} + +int taptools_garden_process(taptools_garden h, double* out, int n) { + if (!out || n < 0) { + return -1; + } + return with(h, [&](garden_bed& g) { g.process(out, static_cast(n)); }); +} + } // extern "C" diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index eb72c34..c820714 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -390,6 +390,33 @@ TAPTOOLS_API double taptools_airport_composite_period_seconds(taptools_airport h /// Process n samples; the stereo loop sum lands in outL/outR (no dry path). TAPTOOLS_API int taptools_airport_process(taptools_airport h, const double* in, double* outL, double* outR, int n); +// ---- tap.garden~ (tap::tools::garden::bed) ------------------------------------------------------- + +typedef void* taptools_garden; + +TAPTOOLS_API taptools_garden taptools_garden_create(void); +TAPTOOLS_API void taptools_garden_destroy(taptools_garden h); +TAPTOOLS_API int taptools_garden_prepare(taptools_garden h, double sr); +/// Plant a note: MIDI pitch (fractional ok, snaps to root/scale at entry), velocity (0, 1]. +TAPTOOLS_API int taptools_garden_note(taptools_garden h, double pitch, double velocity); +TAPTOOLS_API int taptools_garden_set_loop_seconds(taptools_garden h, double s); +TAPTOOLS_API int taptools_garden_set_decay(taptools_garden h, double per_pass); // velocity/pass, 0..1 +TAPTOOLS_API int taptools_garden_set_soften(taptools_garden h, double per_pass); // brightness/pass, 0..1 +TAPTOOLS_API int taptools_garden_set_floor(taptools_garden h, double v); // retirement threshold +/// Bell envelope times in SECONDS + base brightness 0..1 (scales the FM index). +TAPTOOLS_API int taptools_garden_set_bell(taptools_garden h, double attack_s, double decay_s, double brightness); +TAPTOOLS_API int taptools_garden_set_root(taptools_garden h, int semitone); // 0..11, 0 = C +TAPTOOLS_API int taptools_garden_set_scale(taptools_garden h, int scale); // garden::scale_index +TAPTOOLS_API int taptools_garden_set_idle_seconds(taptools_garden h, double s); // 0 disables the gardener +TAPTOOLS_API int taptools_garden_set_seed(taptools_garden h, unsigned long long seed); +TAPTOOLS_API int taptools_garden_set_level(taptools_garden h, double lin); +TAPTOOLS_API int taptools_garden_set_smooth_ms(taptools_garden h, double ms); +TAPTOOLS_API int taptools_garden_clear(taptools_garden h); +TAPTOOLS_API int taptools_garden_active_events(taptools_garden h); // live blooms (-1 on bad handle) +TAPTOOLS_API int taptools_garden_active_voices(taptools_garden h); // ringing bells (-1 on bad handle) +/// A source: renders n samples into out (mono). +TAPTOOLS_API int taptools_garden_process(taptools_garden h, double* out, int n); + #ifdef __cplusplus } #endif From 0fb287a4a0d76df9cf00b1e6a188c7e55a3c2e76 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 12 Aug 2026 01:42:48 +0000 Subject: [PATCH 7/9] Add eno_render: minutes-long listening checks for the family The Eno kernels are long-timescale systems, so offline rendering is the only practical audition. Five scenarios to WAV: the two-machine loop at regen 0.95, the regen-1.0 Frippertronics wash with the send faded at the halfway mark, three stereo minutes of seven incommensurate airport loops, four planted garden notes recirculating to silence, and two minutes of the seeded gardener left alone. Verified non-silent and unclipped end to end. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_016zgrm1MGS1eir4hCfZBJaR --- tools/render/CMakeLists.txt | 2 +- tools/render/eno_render.cpp | 233 ++++++++++++++++++++++++++++++++++++ 2 files changed, 234 insertions(+), 1 deletion(-) create mode 100644 tools/render/eno_render.cpp diff --git a/tools/render/CMakeLists.txt b/tools/render/CMakeLists.txt index 2291633..c4d95ea 100644 --- a/tools/render/CMakeLists.txt +++ b/tools/render/CMakeLists.txt @@ -2,7 +2,7 @@ # through its kernel header to WAV files for listening checks — the kernels' reusability # outside Max, demonstrated in ~150 lines apiece. -foreach (tool diode_render tb303_render ladder_render vco_render grm_comb_render grm_pitchaccum_render autowah_render tr808_render) +foreach (tool diode_render tb303_render ladder_render vco_render grm_comb_render grm_pitchaccum_render autowah_render tr808_render eno_render) add_executable(${tool} ${tool}.cpp) target_link_libraries(${tool} PRIVATE TapTools::taptools) set_target_properties(${tool} PROPERTIES diff --git a/tools/render/eno_render.cpp b/tools/render/eno_render.cpp new file mode 100644 index 0000000..3d8e4b8 --- /dev/null +++ b/tools/render/eno_render.cpp @@ -0,0 +1,233 @@ +/// @file +/// @brief Offline renderer for the Eno family — writes demo WAVs for listening checks. +/// @details Exercises discreet.h, airport.h, and garden.h with no Max involved (the kernels' +/// portability, demonstrated) — and, for this family, the only practical audition: +/// these are long-timescale systems, so the scenarios run minutes, not seconds. +/// +/// Scenarios: `discreet_basic` (a phrase into the two-machine loop at regen 0.95), +/// `discreet_sustain` (regen 1.0 with drive — the Frippertronics wash, input faded +/// out at the halfway mark), `airport_two_one` (seven incommensurate loops, stereo, +/// three minutes), `garden_played` (four planted notes recirculating to silence), +/// and `garden_idle` (the seeded gardener left alone for two minutes). +/// +/// Usage: eno_render [output-directory] (default: current directory) +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace { + + constexpr double k_g_sr = 48000.0; + constexpr double k_g_pi = 3.14159265358979323846; + + /// 48 kHz float32 WAV, 1 or 2 channels (interleaved) — same writer as the other render tools. + bool write_wav(const std::string& path, const std::vector& samples, double sr, uint16_t channels = 1) { + std::FILE* f = std::fopen(path.c_str(), "wb"); + if (!f) { + std::fprintf(stderr, "cannot open %s\n", path.c_str()); + return false; + } + const uint32_t n = static_cast(samples.size()); + const uint32_t data_bytes = n * 4; + const uint32_t rate = static_cast(sr); + + auto u16 = [&](uint16_t v) { std::fwrite(&v, 2, 1, f); }; + auto u32 = [&](uint32_t v) { std::fwrite(&v, 4, 1, f); }; + + std::fwrite("RIFF", 1, 4, f); + u32(36 + data_bytes); + std::fwrite("WAVE", 1, 4, f); + std::fwrite("fmt ", 1, 4, f); + u32(16); + u16(3); // IEEE float + u16(channels); + u32(rate); + u32(rate * 4 * channels); + u16(static_cast(4 * channels)); // block align + u16(32); // bits + std::fwrite("data", 1, 4, f); + u32(data_bytes); + for (double s : samples) { + const float v = static_cast(s); + std::fwrite(&v, 4, 1, f); + } + std::fclose(f); + std::printf("wrote %s (%.1f s)\n", path.c_str(), n / (sr * channels)); + return true; + } + + /// A soft additive phrase tone: fundamental + two harmonics under a sine^2 swell. + double phrase_tone(double t, double dur, double hz) { + if (t < 0.0 || t >= dur) { + return 0.0; + } + const double env = std::pow(std::sin(k_g_pi * std::min(t / (0.66 * dur), 1.0)), 2.0); + return env + * (0.5 * std::sin(2.0 * k_g_pi * hz * t) + 0.22 * std::sin(2.0 * k_g_pi * 2.0 * hz * t) + + 0.1 * std::sin(2.0 * k_g_pi * 3.0 * hz * t)); + } + + double midi_hz(double pitch) { + return 440.0 * std::exp2((pitch - 69.0) / 12.0); + } + + void discreet_basic(const std::string& dir) { + tap::tools::discreet::machine m; + m.prepare(k_g_sr, 10.0); + m.set_loop_seconds(5.0); + m.set_regen(0.95); + m.set_drive(0.4); + m.set_darken_hz(3500.0); + m.set_mix(60.0); + + // Four slow notes in the first fifteen seconds, then the machine on its own. + const double notes[][2] = {{57, 0.5}, {64, 8.0}, {62, 15.0}, {69, 21.0}}; + std::vector y(static_cast(90.0 * k_g_sr)); + for (size_t i = 0; i < y.size(); ++i) { + const double t = static_cast(i) / k_g_sr; + double in = 0.0; + for (const auto& n : notes) { + in += 0.5 * phrase_tone(t - n[1], 4.0, midi_hz(n[0])); + } + y[i] = m.process(in); + } + write_wav(dir + "/discreet_basic.wav", y, k_g_sr); + } + + void discreet_sustain(const std::string& dir) { + tap::tools::discreet::machine m; + m.prepare(k_g_sr, 10.0); + m.set_loop_seconds(6.5); + m.set_regen(1.0); // the point of the kernel: wear is the stabilizer + m.set_drive(0.7); + m.set_darken_hz(2200.0); + m.set_mix(100.0); + m.set_smooth_ms(2000.0); + + const double notes[][2] = {{45, 0.5}, {57, 5.0}, {60, 11.0}, {64, 17.0}, {67, 24.0}}; + std::vector y(static_cast(120.0 * k_g_sr)); + bool faded = false; + for (size_t i = 0; i < y.size(); ++i) { + const double t = static_cast(i) / k_g_sr; + double in = 0.0; + for (const auto& n : notes) { + in += 0.45 * phrase_tone(t - n[1], 5.0, midi_hz(n[0])); + } + if (!faded && t >= 60.0) { // the performance move: fade the send, the wash remains + m.set_input_level(0.0); + faded = true; + } + y[i] = m.process(in); + } + write_wav(dir + "/discreet_sustain.wav", y, k_g_sr); + } + + void airport_two_one(const std::string& dir) { + tap::tools::airport::loop_bank b; + b.prepare(k_g_sr, 32.0); + + // Seven loops in the spirit of the published description: long, mutually incommensurate, + // one soft phrase each. Lengths are deliberately awkward ratios of one another. + const double lengths[7] = {17.8, 19.1, 21.3, 23.9, 26.2, 28.7, 30.9}; + const double pitches[7] = {57, 60, 62, 64, 65, 69, 72}; + const double pans[7] = {-0.8, 0.8, -0.45, 0.45, -0.15, 0.15, 0.0}; + b.set_loops(7); + for (int i = 0; i < 7; ++i) { + b.set_length_seconds(i, lengths[i]); + b.set_level(i, 0.45); + b.set_pan(i, pans[i]); + } + b.set_darken_hz(2, 4000.0); + b.set_darken_hz(4, 4000.0); + + std::vector stereo; + stereo.reserve(static_cast(180.0 * k_g_sr) * 2); + double l = 0.0, r = 0.0; + + // Record one phrase onto each loop in turn, then let the system run free. + for (int i = 0; i < 7; ++i) { + const double dur = 0.55 * lengths[i]; + b.record(i, true); + const size_t n = static_cast(dur * k_g_sr); + for (size_t s = 0; s < n; ++s) { + b.process(phrase_tone(static_cast(s) / k_g_sr, dur, midi_hz(pitches[i])), l, r); + stereo.push_back(l); + stereo.push_back(r); + } + b.record(i, false); + } + while (stereo.size() < static_cast(180.0 * k_g_sr) * 2) { + b.process(0.0, l, r); + stereo.push_back(l); + stereo.push_back(r); + } + write_wav(dir + "/airport_two_one.wav", stereo, k_g_sr, 2); + } + + void garden_played(const std::string& dir) { + tap::tools::garden::bed g; + g.prepare(k_g_sr); + g.set_loop_seconds(5.0); + g.set_decay(0.8); + g.set_soften(0.85); + g.set_bell(0.1, 2.5, 0.9); + g.set_scale(tap::tools::garden::scale_major_pentatonic); + g.set_root(9); + g.set_idle_seconds(0.0); // played only: no gardener in this render + g.set_level(0.4); + + const double plants[][3] = {{69, 0.7, 0.2}, {76, 0.5, 1.7}, {64, 0.6, 3.4}, {81, 0.4, 4.6}}; + std::vector y(static_cast(75.0 * k_g_sr)); + size_t next = 0; + for (size_t i = 0; i < y.size(); ++i) { + const double t = static_cast(i) / k_g_sr; + if (next < 4 && t >= plants[next][2]) { + g.note(plants[next][0], plants[next][1]); + ++next; + } + y[i] = g.process(); + } + write_wav(dir + "/garden_played.wav", y, k_g_sr); + } + + void garden_idle(const std::string& dir) { + tap::tools::garden::bed g; + g.prepare(k_g_sr); + g.set_loop_seconds(6.0); + g.set_decay(0.85); + g.set_soften(0.9); + g.set_bell(0.12, 3.0, 0.9); + g.set_scale(tap::tools::garden::scale_minor_pentatonic); + g.set_root(2); + g.set_idle_seconds(3.0); + g.set_seed(2008); + g.set_level(0.4); + + std::vector y(static_cast(120.0 * k_g_sr)); + for (auto& s : y) { + s = g.process(); + } + write_wav(dir + "/garden_idle.wav", y, k_g_sr); + } + +} // namespace + +int main(int argc, char** argv) { + const std::string dir = (argc > 1) ? argv[1] : "."; + discreet_basic(dir); + discreet_sustain(dir); + airport_two_one(dir); + garden_played(dir); + garden_idle(dir); + return 0; +} From e1da6eeb2d3c32b6bf528500628f29ba9c177963 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 12 Aug 2026 01:44:47 +0000 Subject: [PATCH 8/9] Plan the Eno-family chapters MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit book/PLAN-eno-chapters.md: the drafting record for three user-facing chapters and three machine appendices, per the PLAN-pitch-chapters.md shape — SUMMARY placement diff, per-chapter outlines with every numbered item carrying its evidence (notebook section or pinned test scenario), figure list, and drafting notes. Status: planned; flips to drafted when the chapters land. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_016zgrm1MGS1eir4hCfZBJaR --- book/PLAN-eno-chapters.md | 218 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 218 insertions(+) create mode 100644 book/PLAN-eno-chapters.md diff --git a/book/PLAN-eno-chapters.md b/book/PLAN-eno-chapters.md new file mode 100644 index 0000000..c38607a --- /dev/null +++ b/book/PLAN-eno-chapters.md @@ -0,0 +1,218 @@ +# Plan — the Eno-family chapters + +> **Status: planned.** Outline for drafting; flips to drafted when the chapters land in +> `src/` per the placement below. This file then remains as the drafting record, the +> plans-directory way. + +Planning document for the *Tools on Tap* chapters covering the 2026-08 Eno-family work +(`tap.discreet~`, `tap.airport~`, `tap.garden~`; `taptools/tape_loop.h`, `discreet.h`, +`airport.h`, `garden.h`). Six chapters: three user-facing, three machine appendices. This +file is the outline to draft from; it is not part of the built book. + +Every measured claim below already exists as an executed notebook cell or a pinned test — +each section lists its evidence so the chapters keep the book's "measured, not remembered" +promise without new lab work. + +The family's single thesis, which every chapter should serve and none should re-derive from +scratch: three Brian Eno works are the same idea at three levels of abstraction — +*Discreet Music* (1975) recirculates **audio**, *Music for Airports* "2/1" (1978) phases +**loops**, and the Bloom principle (2008) recirculates **events** — and in all three, +**degradation is the stability mechanism**. Where every other feedback loop in this library +caps its gain below one (`delay.h`'s `k_fb_max`, the comb bank's calibrated ring), these +kernels let regeneration reach exactly 1.0 and stay bounded because each pass is worn: +darkened and saturated in the tape kernels, decayed and softened in the garden. + +## Placement in SUMMARY.md + +Insert a new part after Part III (Strings, rooms, and spirals); Parts IV–IX renumber to +V–X. The three machine entries slot after `machine/overdrive.md`, keeping the file-by-file +order chronological. + +```md +# Part IV — Tape and time + +- [The tape that forgets slowly](discreet.md) +- [Loops that never line up](airport.md) +- [The garden that plays itself](garden.md) + +# Part IX — The machine, file by file + ...existing entries... +- [The clipper in the loop: overdrive.h](machine/overdrive.md) +- [Wear as the stabilizer: tape_loop.h and discreet.h](machine/tape.md) +- [Free-running heads, one shared clock: airport.h](machine/airport.md) +- [Events, not audio: garden.h](machine/garden.md) +``` + +The user chapters cross-reference `recipes/shimmer.md` (which already credits Eno/Lanois +for the shimmer school) rather than re-telling that lineage. + +## Figures + +Hand-authored block diagrams in the house style (grey main path, colored emphasis paths, +dashed rate regions): `images/discreet/block-diagram.svg` (the two-machine loop, wear path +in red like the comb's feedback ring), `images/airport/block-diagram.svg` (seven reels, one +free-running head each), `images/garden/block-diagram.svg` (event ring feeding the bell +pool, the gardener dashed). + +Measured figures generated by `book/figures/eno.py` (the `overdrive.py` regeneration +contract: drives the shipping kernels through the C ABI, never re-implementations): +`images/discreet/generation-loss.svg` (per-pass two-tone decay vs. the analytic wear +transfer), `images/airport/raster.svg` (return raster of two incommensurate loops, lcm +marked), `images/garden/staircase.svg` (the decay-0.5 return staircase). + +--- + +## Chapter 1 (user-facing) — *The tape that forgets slowly* (`src/discreet.md`) + +The image: a machine whose memory is the instrument — everything you play into it comes +back five seconds later a little darker and a little softer, forever if you ask. The +inversion to sell in one paragraph: this is the one delay in the house allowed to run at +regeneration 1.0, *because* it forgets. + +1. Provenance: the schematic on the *Discreet Music* back cover; Fripp's rig; the AES + Echoplex-model literature for the tape path. *Evidence: header @details; no measurement.* +2. The echo grid and what "one loop later" means. *Evidence: discreet.ipynb §1; scenario + "the loop echoes at exactly the loop period".* +3. `regen` — and why 1.0 is legal here and illegal in tap.delay~. The wear path as the + stabilizer. *Evidence: discreet.ipynb §2 (20 s bounded RMS at regen 1.0); scenario + "regen 1.0 with drive engaged is bounded and does not grow".* +4. `darken` and `drive` — generation loss, measured against the analytic per-pass transfer + (0.292 at 6 kHz, 0.890 at 300 Hz per pass, both matching prediction to three decimals). + *Evidence: discreet.ipynb §3; scenario "every pass through the loop is darker by the + wear filter".* Figure: `generation-loss.svg`. +5. `wow`/`flutter` — the transport, in cents (10.9 measured vs 10.9 predicted), and the + determinism contract. *Evidence: discreet.ipynb §4; scenario "wow bends pitch by the set + depth, and two runs are bit-exact".* +6. `loop` moves are tape speed — the doppler is honest, not a defect. *Evidence: scenario + "a loop-time change glides as tape speed, not a splice".* +7. `input_level` — the performance move: fade the send, the piece continues. *Evidence: + discreet.ipynb §5; eno_render discreet_sustain.* +8. Recipes: the Discreet Music bed; Frippertronics duo (regen 1.0, drive up); haunted + slapback (short loop, heavy wow); infinite pad sustainer. +9. When it is not the right tool: rhythmic delays that must not bend pitch (tap.delay~); + multitap patterns (tap.multitap~); anything needing a dry-signal guarantee at regen 1.0. +10. Checkpoint. + +## Chapter 2 (user-facing) — *Loops that never line up* (`src/airport.md`) + +The image: seven tape loops of awkward lengths, each holding one phrase, all turning at +once — composition by coincidence. The chapter should make the reader feel that the +*lengths are the score*. + +1. Provenance: Eno's published account of "2/1"; the machine keeps the loops turning, the + incommensurability does the composing. *Evidence: header @details.* +2. Record and return: punch-in at the head, bit-exact freeze, no downbeat, no reset — + the free-run is the piece. *Evidence: airport.ipynb §1; scenarios "a recorded phrase + returns every loop period and no setter resets the phase", "record off freezes the tape + bit-exactly".* +3. The composite period: 24000- and 30000-sample loops realign at exactly 2.5 s + (`composite_period_seconds`), and seven airport-scale loops overflow to infinity — + which is the point. *Evidence: airport.ipynb §2; scenario "two incommensurate loops + realign only at the lcm".* Figure: `raster.svg`. +4. Level, pan, darken: placing phrases in the field; the shade is a playback tone, not + generation loss (a frozen loop replays the same imprint — the honest non-feature), + measured at 0.169 vs 0.169 predicted. *Evidence: airport.ipynb §3; scenarios + "a hard-panned loop is bitwise absent from the far bus", "darken shades one loop's + playback and only that loop's".* +5. Splices: what a length change does and why it may click. *Evidence: scenario "a length + change is a splice: phase re-wraps and never rewinds".* +6. Recipes: the "2/1" bed (seven loops, published-spirit ratios); two-loop phase study + (Reich-adjacent); one-loop sound-on-sound sketchpad; run sources through tap.discreet~ + first for tape breath (cross-reference, wow is deliberately absent here). +7. When it is not the right tool: synchronized loopers (this one never lines up by + design); beat-locked material; per-pass degradation (that is tap.discreet~'s job). +8. Checkpoint. + +## Chapter 3 (user-facing) — *The garden that plays itself* (`src/garden.md`) + +The image: an instrument you tend rather than play — plant a note, it returns each pass a +step quieter and purer until it fades; stop playing and the garden keeps itself. Name the +IP posture plainly (the principle from published descriptions; no Bloom tables, timings, or +sounds; "Bloom" is Opal's trademark — the tune.md history paragraph is the template for +this kind of honesty). + +1. Provenance and the third abstraction level: audio → loops → events; per-pass decay is + the same stabilizer wearing its third costume. *Evidence: header @details.* +2. Plant and return: the staircase (0.795, 0.399, 0.2, 0.1, 0.05, silence) and the + retirement arithmetic — the population converges by construction. *Evidence: + garden.ipynb §1; scenarios "a planted note blooms again every loop period", "each + return is quieter by the decay ratio and the bloom retires below the floor".* Figure: + `staircase.svg`. +3. `soften` — returns get purer, not just quieter: the FM sideband fades while the + fundamental holds. *Evidence: garden.ipynb §2; scenario "each return is purer: the fm + partial fades by the soften ratio".* +4. The scale contract: thirteen chromatic plants, every bloom on the pentatonic by the + YIN oracle; quantize-at-entry and why wrong notes are impossible. *Evidence: + garden.ipynb §3; scenario "every bloom lands on the scale".* +5. The gardener: idle threshold, one plant per pass, and the seed triad (bit-exact / + different / cannot-matter) — the library's first randomized event source, with the + tr808 seed contract as the bridge back to reproducibility. *Evidence: garden.ipynb §4; + scenarios "the seeded garden is bit-exact per seed...", "left alone, the garden starts + playing after idle_seconds — and never when idle is disabled".* +6. Bounds you can lean on: 64 events (oldest yields), 16 bells (quietest stolen, + envelopes re-aimed not reset). *Evidence: scenarios "when the garden is full the + oldest bloom yields to the newest", "the bell pool never exceeds its size...".* +7. Recipes: the lobby garden (defaults, long idle); the music box (fast decay, no + gardener); the endless install (seeded, level low, walk away); duet mode (idle short, + trade phrases with the gardener). +8. When it is not the right tool: melodies with wrong notes in them (quantization is + always on); rhythm outside the loop grid; any timbre that is not a soft bell. +9. Checkpoint. + +## Chapter 4 (machine) — *Wear as the stabilizer: tape_loop.h and discreet.h* +(`src/machine/tape.md`) + +The centerpiece of the family's engineering story. Sections in code order: the shared +header decision (class-with-state → shared header, the swing_vca.h precedent; the ramp and +Hermite read as cited copies); `reel` and the one wrap that serves two topologies; +`wow_flutter` and the periodic-only decision (testability as a design force); `wear` and +the boundedness argument (swing_shape bounded by 1/drive ⇒ BIBO at regen 1.0; the +normalized DC blocker; what drive 0 promises and what it does not); the doppler decision +told as a design choice (moving the read head IS the tape speed — no crossfade mode); the +LLP64 head-wrap note. One section told as a finding: the notebook's per-pass measurement +landing on the analytic transfer to three decimals — the moment the model and the +arithmetic agreed. The engineering ledger: analytic-transfer oracle, two-window RMS +non-growth (the grm_comb swell story inherited), YIN as transport oracle, bitwise endpoint +laws. *Evidence: discreet_test.cpp scenarios (all), discreet.ipynb §§1–5.* + +## Chapter 5 (machine) — *Free-running heads, one shared clock: airport.h* +(`src/machine/airport.md`) + +Sections: the loop_state shape (multitap's fixed-array idiom with a reel per slot); the +phase discipline (never reset — enumerate what may and may not touch it, and the +setter-storm test that pins it); record semantics (replace at the head, read-before-write, +the two-sample Hermite blend at the punch, no overdub by provenance); the splice +arithmetic; the darken bypass at the band ceiling (bit-transparency as a testable +contract); composite_period_seconds (gcd/lcm in long long, overflow → +inf as a feature). +Finding section: the raster plot making the 2.5 s lcm visible before the assertion pinned +it. Ledger: bitwise structural assertions over spectral ones wherever the promise allows. +*Evidence: airport_test.cpp scenarios (all), airport.ipynb §§1–4.* + +## Chapter 6 (machine) — *Events, not audio: garden.h* (`src/machine/garden.md`) + +Sections: the event ring (fixed 64, seq-numbered, oldest-yields — the musical argument for +the overflow policy); the fire/bloom split and why note() does not sound the voice itself +(the double-trigger it avoids); the bell (2-op FM at ratio 3, why harmonicity was a test +requirement before it was an aesthetic; decay_env reuse; steal-by-re-aim); quantize-at- +entry (the tune.h mask idiom, copied not included, and the coupling argument); the +gardener (consumption discipline: rng touched only when idling — the cannot-matter leg of +the triad depends on it); the population-convergence arithmetic as the header's stated +theorem. Finding section: the onset-detector rewrite — exponential tails never reach zero, +so "returns on the grid" had to be pinned by threshold, an honest lesson about testing +envelopes. Ledger: the seed triad as contract, YIN for the scale promise, Goertzel for the +softening trajectory. *Evidence: garden_test.cpp scenarios (all), garden.ipynb §§1–5.* + +## Notes for drafting + +- Voice: the person patching, not the person marketing. The family chapters may assume + the reader has met `delay.h`'s feedback story (Part III) — the inversion lands harder + against it. +- Title alternates considered and rejected: "The two tape machines" (names the rig, not + the image), "Airport music" (flip), "Bloom, recreated" (trademark in a title — no). +- Figures: regenerate rather than screenshot (`book/figures/eno.py`); notebook previews + are decimated for repo size, figures are full-rate measurements. +- Cross-repo linking: none needed here (all four headers live in this repo); the + machine/spectral.md convention is not required. +- The render tool (`eno_render`) is the listening companion; chapters may point at its + scenario names for "hear this" moments but must not cite it for numbers — numbers come + from the notebooks and tests only. From aed8ad0e11d94f22fcd4ac51a40668fedbb66a24 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 12 Aug 2026 01:51:47 +0000 Subject: [PATCH 9/9] Write the Tape and time chapters MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A new Part IV for the Eno family — "The tape that forgets slowly", "Loops that never line up", "The garden that plays itself" — plus three machine appendices (tape_loop.h/discreet.h, airport.h, garden.h) closing Part IX, with later parts renumbered. Hand-authored block diagrams in the house style for all three objects, measured figures generated by book/figures/eno.py against the shipping kernels (generation loss on the analytic wear transfer, the incommensurate-loop raster with its 2.5 s lcm, the decay staircase), and the PLAN flipped to drafted. The part's through-line is the family thesis: three works, one idea at three abstraction levels, and in all three degradation is the stability mechanism. Every number in the chapters cites its executed notebook cell or pinned test scenario; mdbook 0.4.40 (the CI pin) builds clean. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_016zgrm1MGS1eir4hCfZBJaR --- book/PLAN-eno-chapters.md | 5 +- book/figures/eno.py | 161 + book/src/SUMMARY.md | 21 +- book/src/airport.md | 117 + book/src/discreet.md | 134 + book/src/garden.md | 121 + book/src/images/airport/block-diagram.svg | 70 + book/src/images/airport/raster.svg | 405 ++ book/src/images/discreet/block-diagram.svg | 76 + book/src/images/discreet/generation-loss.svg | 400 ++ book/src/images/garden/block-diagram.svg | 61 + book/src/images/garden/staircase.svg | 4113 ++++++++++++++++++ book/src/machine/airport.md | 101 + book/src/machine/garden.md | 119 + book/src/machine/tape.md | 120 + 15 files changed, 6015 insertions(+), 9 deletions(-) create mode 100644 book/figures/eno.py create mode 100644 book/src/airport.md create mode 100644 book/src/discreet.md create mode 100644 book/src/garden.md create mode 100644 book/src/images/airport/block-diagram.svg create mode 100644 book/src/images/airport/raster.svg create mode 100644 book/src/images/discreet/block-diagram.svg create mode 100644 book/src/images/discreet/generation-loss.svg create mode 100644 book/src/images/garden/block-diagram.svg create mode 100644 book/src/images/garden/staircase.svg create mode 100644 book/src/machine/airport.md create mode 100644 book/src/machine/garden.md create mode 100644 book/src/machine/tape.md diff --git a/book/PLAN-eno-chapters.md b/book/PLAN-eno-chapters.md index c38607a..be9fa8a 100644 --- a/book/PLAN-eno-chapters.md +++ b/book/PLAN-eno-chapters.md @@ -1,8 +1,7 @@ # Plan — the Eno-family chapters -> **Status: planned.** Outline for drafting; flips to drafted when the chapters land in -> `src/` per the placement below. This file then remains as the drafting record, the -> plans-directory way. +> **Status: drafted.** All six chapters are written and live in `src/` per the placement +> below (2026-08-12). This file remains as the drafting record, the plans-directory way. Planning document for the *Tools on Tap* chapters covering the 2026-08 Eno-family work (`tap.discreet~`, `tap.airport~`, `tap.garden~`; `taptools/tape_loop.h`, `discreet.h`, diff --git a/book/figures/eno.py b/book/figures/eno.py new file mode 100644 index 0000000..d70afa3 --- /dev/null +++ b/book/figures/eno.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +"""Generate the measured figures for the Eno-family book chapters. + +Drives the *shipping* kernels (discreet.h, airport.h, garden.h) through the +C ABI via the notebooks' ctypes bridge — the same rule as the verification +notebooks: figures are measurements of the real DSP, never illustrations of +what it should do. The companion notebooks (notebooks/discreet.ipynb, +airport.ipynb, garden.ipynb) carry the same measurements with commentary; +this script renders the book-styled SVGs. + +Regenerate after a kernel behavior change: + + python3 book/figures/eno.py # writes book/src/images/{discreet,airport,garden}/*.svg + +Colors: the house categorical hues (notebooks/taptools_py.py PALETTE), with +the amber snapped darker (#efb118 -> #b8890f) so pairs pass the print/CVD +lightness-band and separation checks on a light page. Every multi-series +figure carries direct labels, so identity never rides on color alone. +""" + +import pathlib +import sys + +import numpy as np +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt + +sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[2] / "notebooks")) +import taptools_py as tap + +IMAGES = pathlib.Path(__file__).resolve().parents[1] / "src" / "images" + +BLUE, AMBER, RED = "#4269d0", "#b8890f", "#ff725c" +INK, MUTED = "#1a1a1a", "#666666" + +plt.rcParams.update({ + "figure.dpi": 96, "figure.figsize": (7.2, 3.1), + "svg.fonttype": "none", "font.family": "sans-serif", "font.size": 9.5, + "axes.grid": True, "grid.alpha": 0.22, "grid.linewidth": 0.5, + "axes.spines.top": False, "axes.spines.right": False, + "axes.edgecolor": MUTED, "axes.labelcolor": INK, + "xtick.color": MUTED, "ytick.color": MUTED, + "axes.titlesize": 10, "axes.titlecolor": INK, + "lines.linewidth": 2.0, "legend.frameon": False, "legend.fontsize": 8.5, +}) + +fs = 48000.0 + + +def out_dir(name): + d = IMAGES / name + d.mkdir(parents=True, exist_ok=True) + return d + + +def tone(x, f): + n = np.arange(x.size) + return 2.0 * np.abs(np.dot(x, np.exp(-2j * np.pi * f * n / fs))) / x.size + + +def generation_loss(): + """discreet: per-pass two-tone decay vs. the analytic wear transfer.""" + m = tap.Discreet(fs, 8.0, smooth_ms=0, wow=(0, 0), flutter=(0, 0), mix=100, + input_level=1.0, loop_seconds=0.25, regen=0.9, drive=0.0, + darken_hz=2000.0) + f_hi, f_lo = 6000.0, 300.0 + n_burst = int(0.1 * fs) + tt = np.arange(n_burst) / fs + x = np.zeros(int(1.6 * fs)) + x[:n_burst] = 0.4 * np.sin(2 * np.pi * f_hi * tt) + 0.4 * np.sin(2 * np.pi * f_lo * tt) + y = m.process(x) + + def wear_gain(f, cutoff): + w = 2 * np.pi * f / fs + a = 1.0 - np.exp(-2 * np.pi * cutoff / fs) + ejw = np.exp(-1j * w) + lp = np.abs(a / (1 - (1 - a) * ejw)) + r, nm = 0.999, (1 + 0.999) / 2 + return lp * np.abs(nm * (1 - ejw) / (1 - r * ejw)) + + loop = int(0.25 * fs) + passes = np.arange(1, 6) + hi = [tone(y[k * loop: k * loop + n_burst], f_hi) for k in passes] + lo = [tone(y[k * loop: k * loop + n_burst], f_lo) for k in passes] + pred_hi = hi[0] * (0.9 * wear_gain(f_hi, 2000.0)) ** (passes - 1) + pred_lo = lo[0] * (0.9 * wear_gain(f_lo, 2000.0)) ** (passes - 1) + + fig, ax = plt.subplots() + ax.semilogy(passes, pred_lo, "-", color=AMBER, lw=1.2, alpha=0.7) + ax.semilogy(passes, lo, "s", color=AMBER, ms=6) + ax.semilogy(passes, pred_hi, "-", color=BLUE, lw=1.2, alpha=0.7) + ax.semilogy(passes, hi, "o", color=BLUE, ms=6) + ax.text(2.1, lo[1] * 1.45, "300 Hz — below the corner", color=AMBER) + ax.text(1.6, hi[1] * 0.5, "6 kHz — above it", color=BLUE) + ax.set_xticks(passes) + ax.set_xlabel("pass through the loop") + ax.set_ylabel("tone level") + ax.set_title("generation loss, measured (points) vs. regen · |H_wear| (lines)") + fig.savefig(out_dir("discreet") / "generation-loss.svg", bbox_inches="tight") + plt.close(fig) + + +def raster(): + """airport: return raster of two incommensurate loops; the lcm marked.""" + b = tap.Airport(fs, 2.0, smooth_ms=0, lengths=[0.5, 0.625], pans=[-1.0, 1.0]) + click = np.zeros(1) + click[0] = 1.0 + for i in (0, 1): + b.record(i, True) + b.process(click) + b.record(i, False) + yl, yr = b.process(np.zeros(int(7.5 * fs))) + hits_a = np.flatnonzero(yl > 0.5) / fs + hits_b = np.flatnonzero(yr > 0.5) / fs + + fig, ax = plt.subplots(figsize=(7.2, 2.3)) + ax.eventplot([hits_a, hits_b, np.concatenate([hits_a, hits_b])], + colors=[BLUE, AMBER, MUTED], lineoffsets=[2, 1, 0], linelengths=0.75) + for k in (1, 2): + ax.axvline(2.5 * k, color=RED, lw=1.0, ls=":") + ax.text(2.5, 2.72, "composite period: 2.5 s (the lcm)", color=RED, ha="center") + ax.set_yticks([2, 1, 0]) + ax.set_yticklabels(["loop A · 0.5 s", "loop B · 0.625 s", "the sum"]) + ax.set_xlabel("time (s)") + ax.set_ylim(-0.6, 3.0) + ax.grid(axis="y", alpha=0) + fig.savefig(out_dir("airport") / "raster.svg", bbox_inches="tight") + plt.close(fig) + + +def staircase(): + """garden: the decay-0.5 return staircase, retiring below the floor.""" + g = tap.Garden(fs, smooth_ms=0, idle_seconds=0, loop_seconds=0.5, + decay=0.5, floor=0.05, bell=(0.002, 0.05, 1.0), scale=0) + g.note(69, 0.8) + y = g.process(int(3.5 * fs)) + + t = np.arange(y.size) / fs + fig, ax = plt.subplots() + ax.plot(t, y, color=BLUE, lw=0.5) + for k in range(5): + v = 0.8 * 0.5 ** k + ax.plot([k * 0.5, k * 0.5 + 0.22], [v, v], color=AMBER, lw=1.6) + ax.text(k * 0.5 + 0.24, v, f"{v:g}", color=AMBER, va="center", fontsize=8.5) + ax.axhline(0.05, color=RED, lw=0.9, ls=":") + ax.text(3.44, 0.075, "floor 0.05 — retirement", color=RED, ha="right", fontsize=8.5) + ax.set_xlabel("time (s)") + ax.set_ylabel("output") + ax.set_title("decay 0.5: each return half as loud, then the bloom retires") + fig.savefig(out_dir("garden") / "staircase.svg", bbox_inches="tight") + plt.close(fig) + + +if __name__ == "__main__": + generation_loss() + raster() + staircase() + print("wrote", *(str(p) for p in sorted(IMAGES.glob("*/generation-loss.svg"))), + str(IMAGES / "airport" / "raster.svg"), str(IMAGES / "garden" / "staircase.svg")) diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md index 39d9fc7..2e0cd65 100644 --- a/book/src/SUMMARY.md +++ b/book/src/SUMMARY.md @@ -18,26 +18,32 @@ - [Five strings, no guitar](fivecomb.md) - [The spiral staircase](pitchaccum.md) -# Part IV — The spectral set +# Part IV — Tape and time + +- [The tape that forgets slowly](discreet.md) +- [Loops that never line up](airport.md) +- [The garden that plays itself](garden.md) + +# Part V — The spectral set - [Making the machine talk](vocoder.md) - [A gate for every bin](nr.md) - [The spectrum, re-plumbed](spectra.md) -# Part V — The rhythm section +# Part VI — The rhythm section - [The acid machine](acid.md) - [The drum machine](drums.md) -# Part VI — Staying in tune +# Part VII — Staying in tune - [The note you meant](tune.md) -# Part VII — The pedalboard +# Part VIII — The pedalboard - [Distortion with a memory](overdrive.md) -# Part VIII — The machine, file by file +# Part IX — The machine, file by file - [Solving the filter on paper: svf.h](machine/svf.md) - [The nonlinear loop: ladder.h](machine/ladder.md) @@ -55,8 +61,11 @@ - [Three ways to move a pitch: yin.h, psola.h, pvoc.h](machine/pitch.md) - [The nearest allowed note: tune.h](machine/tune.md) - [The clipper in the loop: overdrive.h](machine/overdrive.md) +- [Wear as the stabilizer: tape_loop.h and discreet.h](machine/tape.md) +- [Free-running heads, one shared clock: airport.h](machine/airport.md) +- [Events, not audio: garden.h](machine/garden.md) -# Part IX — Recipes +# Part X — Recipes - [How to read a recipe](recipes/cookbook.md) - [One machine, four decades](recipes/808-classics.md) diff --git a/book/src/airport.md b/book/src/airport.md new file mode 100644 index 0000000..276d4a0 --- /dev/null +++ b/book/src/airport.md @@ -0,0 +1,117 @@ +# Loops that never line up + +Take seven tape loops of deliberately awkward lengths — none a multiple of +another — put one soft phrase on each, and let them all turn at once. Each +loop is trivial: it plays the same thing forever. The *system* is not: the +phrases drift against each other, meet, part, and meet again differently, +and the pattern of coincidences does not repeat within a human afternoon. +That is "2/1" from Brian Eno's *Music for Airports* (Ambient 1, EG, 1978), +as he described the rig in the album's liner notes and in *A Year with +Swollen Appendices*: the lengths are the score, and the machine's whole job +is to keep the loops turning without an opinion. `tap.airport~` is that +machine — up to eight free-running loops, each with a single head that both +plays and records, summed to stereo. + +The discipline that makes it the instrument it is: **nothing resets a +phase.** Not recording, not a level move, not a pan, not even a length +change. The free-run *is* the composition, and the kernel treats the heads +as sacred; the test suite literally hammers every setter mid-run and then +checks that the heads have advanced by exactly the samples processed. + +Companion material: the executed notebook `airport.ipynb`, which measured +every claim below, and the `eno_render` tool's `airport_two_one` scenario — +three stereo minutes of seven loops, the listening copy. The Max wrapper +lands in the TapTools-Max package alongside the rest of the family. + +![Signal-flow diagram of tap.airport~: one tape loop of eight drawn as a circle with a single play-and-record head, input through a record gate, playback through darken, level, and equal-power pan into stereo sums, with the other loops ghosted behind](images/airport/block-diagram.svg) + +*One loop of eight. The head plays, then records, then advances; nobody ever tells it where to be.* + +## Record and return + +`record(loop, 1)` punches the input onto that loop's tape at wherever its +head happens to be — there is no downbeat, no quantized punch-in, because +Eno's rig had none. Recording *replaces* (each phrase was recorded once, not +overdubbed), and playback reads just ahead of the write, so while recording +you hear the previous generation under the head. `record(loop, 0)` freezes +the tape, and freezes it bit-exactly: the pinned test compares two whole +passes of a frozen loop and requires them identical to the bit. A loop is +not a degrading medium here — it replays the *same* magnetic imprint every +revolution, which is why this kernel deliberately has no per-pass +generation loss (that is `tap.discreet~`'s physics, not a loop's). + +## The lengths are the score + +`length_seconds` per loop is where the composing happens. Two loops of +24000 and 30000 samples realign only at their least common multiple — +120000 samples, 2.5 seconds — and the kernel will tell you: +`composite_period_seconds` reports exactly 2.5 for that pair, confirmed in +the notebook by rendering the coincidence raster and watching it repeat at +2.5 s and at no shorter lag. + +![Return raster of two incommensurate loops and their sum, with the 2.5-second composite period marked](images/airport/raster.svg) + +*Two awkward lengths and their coincidences. Stretch the lengths and the composite period leaves the room.* + +Then stretch toward the piece: give seven loops airport-scale lengths in +awkward ratios and the composite period overflows a 64-bit sample count — +the kernel reports infinity, which is not a failure mode. It is the point. + +Changing a length while running is a *splice*: the tape keeps its content +and the head re-wraps modulo the new length — never rewinding — exactly as +cutting a physical loop shorter would land you mid-phrase. It can click. +Splices do. + +## Level, pan, shade + +Each loop has a slewed linear `level`, an equal-power `pan` with exact +endpoints (a hard-panned loop is *bitwise* absent from the far bus — the +same law as `tap.multitap~`), and a `darken` corner that shades that loop's +playback tone. The shade is a static one-pole per loop, not wear: measured +in the notebook, a 6 kHz phrase through a 1 kHz shade lands at 0.169 of its +transparent twin, against an analytic prediction of 0.169. At the band +ceiling — the default — the shade stage is bypassed entirely and playback +is bit-transparent, which is what makes the freeze and hard-pan promises +testable as bitwise facts rather than tolerances. + +There is deliberately no wow here: the phasing engine of "2/1" is the +incommensurate lengths, not pitch drift. If a loop's source should breathe +like tape, run it through `tap.discreet~` on the way in. + +## Recipes + +- **The terminal:** seven loops, `@lengths 17.8 19.1 21.3 23.9 26.2 28.7 + 30.9`, one sustained tone phrase recorded onto each, levels around 0.45, + pans spread wide, a 4 kHz shade on two of them. Let it run. Come back in + an hour; it will not have repeated. +- **Phase study:** two loops, lengths in a near ratio (say 8.0 and 8.1), + the same short phrase on both, panned hard left and right — the + Reich-adjacent version, where the drift itself is the melody. +- **Sound-on-sound sketchpad:** one loop, `@lengths 12.`, record gate on a + footswitch. Punch in fragments as they occur to you; the head's + indifference to your downbeat is the charm. +- **Breathing loops:** patch sources through `tap.discreet~` (gentle wow, + regen 0) before the record gate — tape transport on the way in, stable + free-run once captured. + +## When it is not the right tool + +- **Synchronized looping.** This machine never lines up *by design*. A + beat-locked looper wants a phase reset on the downbeat, which is the one + thing this kernel refuses to do. +- **Degrading loops.** A frozen loop here is bit-eternal. For material that + should wear out as it circulates, `tap.discreet~` is the machine with + the forgetting built in. +- **Dense delay textures.** Eight long loops is a composition system, not + an echo; `tap.multitap~` does a hundred taps without ceremony. + +## Checkpoint + +Up to eight free-running loops, one sacred head each: record replaces at +wherever the head is, freeze is bitwise, splices re-wrap and never rewind, +and no setter touches a phase. Level, exact-endpoint pan, and a bypassable +playback shade place the phrases; the lengths do the composing, and +`composite_period_seconds` tells you how long until the piece repeats — +ideally, longer than you will be alive. Every number above lives twice: as +an executed cell in `airport.ipynb` and as a pinned scenario in +`tests/airport_test.cpp`, which CI runs on every push. diff --git a/book/src/discreet.md b/book/src/discreet.md new file mode 100644 index 0000000..2cceb22 --- /dev/null +++ b/book/src/discreet.md @@ -0,0 +1,134 @@ +# The tape that forgets slowly + +Every other delay in this house is kept honest by a cap: feedback stops just +short of one, because a loop that gains nothing and loses nothing will pile +up until it clips. `tap.discreet~` is built on the opposite bargain. Its +regeneration goes all the way to 1.0 — legally, cleanly, forever — because +the loop *forgets*: every pass through the tape comes back a little darker +and a little softer than it went in. The memory loss is not a defect the +kernel tolerates; it is the mechanism that keeps the machine stable. You are +not patching a delay effect. You are renting a machine whose memory is the +instrument. + +The rig it recreates is printed on the back cover of *Discreet Music* +(Obscure/EG, 1975): Brian Eno's synthesizer feeding one Revox tape machine, +the tape spooling for seconds across the room to a second machine, and the +second machine's playback both sent to the speakers and folded back into the +first machine's record head. It is the same two-machine system Robert Fripp +ran for the *No Pussyfooting* loops. The tape path itself — the fractional +read, the periodic wow and flutter, the in-loop coloration — follows the +published tape-echo modeling literature (Arnardóttir, Abel, and Smith's AES +model of the Echoplex, and Välimäki et al.'s tape-echo work). The schematic +is the score; this kernel is a faithful performance of it. + +Companion material: the executed notebook `discreet.ipynb`, which measured +every claim below, and the `eno_render` tool, whose `discreet_basic` and +`discreet_sustain` scenarios are the listening copies. The Max wrapper lands +in the TapTools-Max package alongside the rest of the family. + +![Signal-flow diagram of tap.discreet~: input through a send-level fader and record head onto seconds of tape, a wow/flutter-modulated play head, an equal-power dry/wet mix out, and a red return path of darkening lowpass, bounded saturation, DC blocker, and regeneration gain back into the record head](images/discreet/block-diagram.svg) + +*Two machines and a spool of tape; the red return is where the forgetting — and therefore the stability — lives.* + +## `loop` — the tape span + +`loop_seconds` is the distance between the machines: how long a phrase +travels before it returns. The kernel test pins the grid to the sample — an +impulse comes back at exactly one loop, bit-for-bit the first time, and +every later return lands within a sample of its grid point. + +Changing the loop while audio runs is a tape-speed change, not a menu +option: the read head physically glides to its new distance, and gliding a +read head *is* doppler. Move from 0.5 s to 0.75 s over half a second and the +playback drops an octave while the transport re-spools, then re-locks on +pitch — the test measures 220 Hz mid-glide and 440 Hz within five cents +after. There is no crossfading "digital" mode, on purpose. If a pitch bend +on loop changes would ruin the patch, this is the wrong delay (see below). + +## `regen` — and why 1.0 is legal here + +`regen` is the return level into the record head, and unlike `tap.delay~`'s +feedback (capped at 0.99), it reaches exactly 1.0. The notebook plays a +one-second noise burst into the loop at regen 1.0 and lets it run for twenty +seconds: the level settles and stays — no growth, no collapse — because the +wear path bounds it. The saturator's output can never exceed 1/drive +regardless of what the loop accumulates, the DC blocker keeps offsets from +stacking, and the darkening lowpass decides *what* survives: lows sustain, +highs surrender. The pinned scenario is blunt about the contract — it +asserts *non-growth*, never decay, because at regen 1.0 sustain is the +promise. Bring `regen` down, or darken harder, to end a piece; `clear` is +the eject button, and regen-1.0 material is gone for good. + +## `darken` and `drive` — the wear + +`darken_hz` is the record/playback corner: every pass through the loop runs +through a one-pole lowpass at this frequency, so a bright phrase sheds its +treble generation by generation while its body lingers. This is measured, +not vibes: with the corner at 2 kHz, a 6 kHz tone loses to 0.292 of itself +per pass and a 300 Hz tone keeps 0.890 — and both numbers match the analytic +transfer of the wear path to three decimals in the executed notebook. + +![Per-pass level of a 300 Hz and a 6 kHz tone recirculating through the loop, measured points landing on the analytic prediction lines](images/discreet/generation-loss.svg) + +*Generation loss, measured against `regen · |H_wear|`. The tape forgets treble first.* + +`drive` is the record-head saturation — the guarantee. At any drive above +zero the loop is absolutely bounded no matter the settings; at drive 0 the +path is exactly linear (a real bit-for-bit passthrough, not "almost") and +the loop leans on darkening alone. Drive around 0.5 is the tape sound; +drive high is the loop slowly compressing itself into a wash. + +## `wow` and `flutter` — the transport + +Two sines, slow-deep and fast-shallow, breathing the play head's position. +The pitch math is honest and checkable: depth times 2π times rate is the +peak deviation, so 2 ms of wow at 0.5 Hz predicts ±10.9 cents — and the +notebook's YIN pitch track measures 10.9. The transport is periodic and +deterministic by design (no stochastic capstan drift): two renders of the +same settings are bit-identical, which is also a pinned test. Set both +depths to 0 for a perfectly still machine. + +## `input_level` — the performance move + +The fader Eno actually rode was not the output — it was the *send*. Play a +few phrases into the machine, then bring `input_level` to zero: the loop +keeps unrolling everything it holds, worn a shade further every pass, and +the piece continues without you. That gesture — set up a system, feed it, +step away — is the whole record, and it is one setter here. `mix` is the +ordinary equal-power dry/wet with bitwise-exact endpoints. + +## Recipes + +- **The Discreet Music bed:** `@loop 5. @regen 0.95 @darken 3500 @drive + 0.4 @mix 60`. Play sparse, slow phrases; stop; listen to what the tape + decides to keep. +- **Frippertronics:** `@loop 6.5 @regen 1. @drive 0.7 @darken 2200 @mix + 100`. Solo over yourself from a minute ago. The wash never clips and + never ends until you end it. +- **Haunted slapback:** `@loop 0.15 @regen 0.85 @wow 4. 0.9 @flutter 0.15 + 12.` — a short loop with a seasick transport; the doppler and the wear + turn a slap delay into a memory of one. +- **The exit:** whatever is running, ride `@regen` from 1. to 0.7 over a + minute. The piece performs its own fade, oldest material first. + +## When it is not the right tool + +- **Rhythmic delays.** Loop changes bend pitch by design, and there is no + tempo sync. `tap.delay~` is the clean line; `tap.multitap~` is the + pattern. +- **Anything that must not color the repeats.** Wear is always in the loop + (drive 0 removes only the saturation, not the darkening you set). If the + tenth echo must equal the first, this machine is philosophically opposed. +- **Loops that should line up with other loops.** One machine, one spool. + For a bank of independent free-running loops, the next chapter's + `tap.airport~` is the instrument. + +## Checkpoint + +Seconds of tape between two machines; a worn return path — darken, saturate, +DC-block — instead of a feedback cap; regeneration to exactly 1.0 because +forgetting is the stabilizer. Loop moves are honest tape-speed doppler, the +transport is two deterministic sines measured in cents, and the send fader +is the performance. Every number above lives twice: as an executed cell in +`discreet.ipynb` and as a pinned scenario in `tests/discreet_test.cpp`, +which CI runs on every push. diff --git a/book/src/garden.md b/book/src/garden.md new file mode 100644 index 0000000..873d5d7 --- /dev/null +++ b/book/src/garden.md @@ -0,0 +1,121 @@ +# The garden that plays itself + +The first two chapters of this part recirculate sound: tape that forgets, +loops that never agree. This one recirculates *decisions*. Plant a note and +it comes back every pass of the loop a step quieter and a step purer, until +it fades below hearing and retires. Plant several and they braid. Stop +planting altogether and, after a patient interval, the garden starts +planting for itself — always on the scale, never in a hurry. You do not +play this instrument so much as tend it, which is exactly the posture Eno +kept asking for: the composer as gardener, not architect. The kernel is +named for that metaphor. + +What it recreates is the *principle* behind Brian Eno and Peter Chilvers' +generative apps (Bloom, 2008), as described in their published interviews +and in Eno's 1996 "Generative Music" talk: touch becomes note, note repeats +and fades, scale makes wrong notes impossible, idleness hands the piece to +the system. The principle only — no scale tables, timings, or sounds are +taken from the app, and its name is a live trademark of Opal Limited, which +is why this object is a garden and not a bloom. (As with `tap.tune~`'s +history paragraph, none of this is legal advice; the project's ship-gate is +a freedom-to-operate review.) + +Companion material: the executed notebook `garden.ipynb`, which measured +every claim below, and the `eno_render` tool's `garden_played` and +`garden_idle` scenarios, the listening copies. The Max wrapper lands in the +TapTools-Max package alongside the rest of the family. + +![Signal-flow diagram of tap.garden~: notes through a scale quantizer into a 64-event ring, fired at their loop positions into a 16-voice FM bell pool, with a red per-pass path multiplying velocity by decay and brightness by soften back into the ring, and a dashed seeded gardener planting into the ring](images/garden/block-diagram.svg) + +*Events on a loop instead of audio on a tape — the same recirculation, one level of abstraction up.* + +## Plant and return + +`note(pitch, velocity)` plants: the pitch snaps to the current root and +scale *at entry*, a soft two-operator FM bell sounds on the next sample, +and the event takes a seat at the loop's current position. Every pass, it +fires again at `velocity × decay`, and below `floor` it retires. The +notebook's staircase is the whole contract in one figure: a plant at 0.8 +with decay 0.5 returns at 0.795, 0.399, 0.2, 0.1, 0.05 — then silence, and +`active_events` reads zero. + +![A rendered waveform showing five returns of one planted note, each half the height of the last, with the measured peak levels labeled and the retirement floor marked](images/garden/staircase.svg) + +*The return staircase: decay 0.5, floor 0.05, and a bloom that knows when it is finished.* + +That arithmetic is also the stability story. The family's inversion — +degradation as the stabilizer — reaches its third form here: a bloom lives +exactly `ceil(log(floor/velocity) / log(decay))` passes, so the population +of live events *converges by construction* no matter how fast you plant. +And beneath the arithmetic sits a hard bound: sixteen bells in a fixed +pool, the quietest stolen when a seventeenth is needed, its envelope +re-aimed rather than reset so a steal glides instead of clicking. + +## `soften` — returns get purer, not just quieter + +Each pass also multiplies the event's *brightness* by `soften`, and +brightness is the bell's FM index: the upper partial fades while the +fundamental holds, so a bloom collapses toward a sine as it recedes — the +tape chapters' generation loss, restated in partials instead of passbands. +The notebook measures the sideband-to-fundamental ratio shrinking every +single return, and the pinned test requires it strictly. + +## The scale contract + +`root` and `scale` (chromatic, major, minor, and both pentatonics — plain +public-domain scale theory) define where plants may land, and quantization +happens at entry: the notebook plants all thirteen chromatic pitches from +60 to 72 into a C major-pentatonic garden and the YIN oracle reads every +sounded note on {C, D, E, G, A}. Wrong notes are not discouraged; they are +unrepresentable, which is most of why instruments in this family feel +effortless to strangers. Because quantization is at entry, changing the +scale re-pitches nothing already planted — the field changes for future +seeds only. + +## The gardener + +`idle_seconds` is the patience: that long after your last plant, the +garden begins seeding itself, roughly one note per loop pass, uniformly +placed, on the scale, within two octaves. The randomness is the family's +seeded xorshift64* with the full tr808 contract, pinned as a triad: same +seed, bit-identical garden; different seed, a different garden; gardener +disabled (`idle_seconds 0`), the seed cannot matter at all, because the +generator is never consumed. This is the library's first randomized event +source — `step_seq.h` proudly promises "no randomness anywhere" — and the +seed contract is what lets a generative instrument live in a test suite +that demands reproducibility. + +## Recipes + +- **The lobby:** defaults, `@idle 30. @level 0.4`, plant four or five + notes, walk away. The garden holds the room indefinitely, bounded. +- **The music box:** `@decay 0.5 @soften 0.7 @idle 0 @bell 0.005 0.8 1.` — + no gardener, fast decay: each phrase you play unwinds itself to silence + in a few passes, a wind-up toy running down. +- **The endless install:** `@scale minorpentatonic @root 2 @idle 3. + @seed 2008 @level 0.35`, never touch it again. Same seed next year, + same garden. +- **Duet:** `@idle 6.` and stay at the keyboard — every silence longer + than six seconds, the gardener answers you; every plant of yours resets + its patience. + +## When it is not the right tool + +- **Melodies with wrong notes in them.** Quantization is always on; + chromatic passing tones survive only in `@scale chromatic`, and + micro-tonal pitches not at all. This is a fence, and it is the product. +- **Rhythm.** Events return on the loop grid, exactly, forever — no swing, + no humanization. For patterns as *rhythm*, `tap.808.seq~` is the + machine. +- **Any other timbre.** One soft bell family, on purpose. It is an + instrument, not a polysynth; for FM as a playground, patch oscillators. + +## Checkpoint + +Notes become events; events recirculate on a loop, quieter by `decay` and +purer by `soften` each pass, retiring below `floor`; a sixteen-bell pool +bounds the sound and a sixty-four-seat ring bounds the score, oldest bloom +yielding first. The scale makes wrong notes unrepresentable, and a seeded +gardener keeps the piece alive exactly as long as you neglect it. Every +number above lives twice: as an executed cell in `garden.ipynb` and as a +pinned scenario in `tests/garden_test.cpp`, which CI runs on every push. diff --git a/book/src/images/airport/block-diagram.svg b/book/src/images/airport/block-diagram.svg new file mode 100644 index 0000000..152d639 --- /dev/null +++ b/book/src/images/airport/block-diagram.svg @@ -0,0 +1,70 @@ + + + + + + + + + + + + + + tap.airport~ — one loop of eight, all free-running, lengths never in agreement + + + + + length_seconds of tape — a splice re-wraps, never rewinds + + + + + one head: plays, then records + phase never reset by any setter + + + in + + + record gate + replaces; off = freeze + + + + + + darken + playback tone only — + bypassed at the ceiling + + + level + + + pan + equal-power, + exact endpoints + + + + Σ + + Σ + + out L + + out R + + + + + + … up to 8, each its own length, level, pan, shade + + + + + the composition is the phase system: incommensurate lengths mean the coincidences never repeat — composite period = lcm of the lengths + diff --git a/book/src/images/airport/raster.svg b/book/src/images/airport/raster.svg new file mode 100644 index 0000000..81bfcc5 --- /dev/null +++ b/book/src/images/airport/raster.svg @@ -0,0 +1,405 @@ + + + + + + + + 2026-08-12T01:45:24.202133 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + + + + + + + + + + + + + 2 + + + + + + + + + + + + + 3 + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 5 + + + + + + + + + + + + + 6 + + + + + + + + + + + + + 7 + + + + time (s) + + + + + + + + + + + + + + + + + loop A · 0.5 s + + + + + + + + + + + + + loop B · 0.625 s + + + + + + + + + + + + + the sum + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + composite period: 2.5 s (the lcm) + + + + + + + + + diff --git a/book/src/images/discreet/block-diagram.svg b/book/src/images/discreet/block-diagram.svg new file mode 100644 index 0000000..69d1c22 --- /dev/null +++ b/book/src/images/discreet/block-diagram.svg @@ -0,0 +1,76 @@ + + + + + + + + + + + + + + tap.discreet~ — two machines, seconds of tape, a worn return + + + in + + + input_level + the send fader + + + Σ + + + record head + machine A + + + tape · loop_seconds of spool + worst case bought at prepare() + + + play head + machine B — Hermite read + + + + + mix + equal-power + + out + + + + dry — the note you just played, heard once before the tape has it + + + + wow + flutter + two sines, deterministic + + + + + + darken lowpass + generation loss per pass + + + saturate + tanh(d·v)/d — bounded by 1/d + + + DC blocker + peak gain normalized to 1 + + + × regen + may reach 1.0 + + + the wear path IS the stabilizer: no feedback cap — each pass survives because it is degraded + diff --git a/book/src/images/discreet/generation-loss.svg b/book/src/images/discreet/generation-loss.svg new file mode 100644 index 0000000..c087a75 --- /dev/null +++ b/book/src/images/discreet/generation-loss.svg @@ -0,0 +1,400 @@ + + + + + + + + 2026-08-12T01:45:24.080663 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + + + + + + + + + + + + + 2 + + + + + + + + + + + + + 3 + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 5 + + + + pass through the loop + + + + + + + + + + + + + + + + + + + + 1 + 0 + − + 2 + + + + + + + + + + + + + + + + + + 1 + 0 + − + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + tone level + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 300 Hz — below the corner + + + 6 kHz — above it + + + generation loss, measured (points) vs. regen · |H_wear| (lines) + + + + + + + + + diff --git a/book/src/images/garden/block-diagram.svg b/book/src/images/garden/block-diagram.svg new file mode 100644 index 0000000..1b1ffd2 --- /dev/null +++ b/book/src/images/garden/block-diagram.svg @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + tap.garden~ — events on a loop, bells in a pool, a gardener with a seed + + + note(pitch, vel) + + + quantize + root + scale, at entry + + + + + event ring · 64 blooms + each: pitch, velocity, brightness, + a position on the loop + full → the oldest bloom yields + + + + + fire + when the loop reaches it + + + bell pool · 16 + 2-op FM, ratio 3, decay_env + steal = re-aim the quietest, + never a reset + + out + + + + + velocity × decay · brightness × soften + every pass: quieter and purer + + + below the floor → the bloom retires + per-pass decay IS the stabilizer: the population converges no matter how fast you plant + + + + the gardener + seeded xorshift64* — after + idle_seconds, ~1 plant per pass + + diff --git a/book/src/images/garden/staircase.svg b/book/src/images/garden/staircase.svg new file mode 100644 index 0000000..4f1d367 --- /dev/null +++ b/book/src/images/garden/staircase.svg @@ -0,0 +1,4113 @@ + + + + + + + + 2026-08-12T01:45:24.340888 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.5 + + + + + + + + + + + + + 1.0 + + + + + + + + + + + + + 1.5 + + + + + + + + + + + + + 2.0 + + + + + + + + + + + + + 2.5 + + + + + + + + + + + + + 3.0 + + + + + + + + + + + + + 3.5 + + + + time (s) + + + + + + + + + + + + + + + + + −0.8 + + + + + + + + + + + + + −0.6 + + + + + + + + + + + + + −0.4 + + + + + + + + + + + + + −0.2 + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.2 + + + + + + + + + + + + + 0.4 + + + + + + + + + + + + + 0.6 + + + + + + + + + + + + + 0.8 + + + + output + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0.8 + + + 0.4 + + + 0.2 + + + 0.1 + + + 0.05 + + + floor 0.05 — retirement + + + decay 0.5: each return half as loud, then the bloom retires + + + + + + + + + diff --git a/book/src/machine/airport.md b/book/src/machine/airport.md new file mode 100644 index 0000000..bd3e703 --- /dev/null +++ b/book/src/machine/airport.md @@ -0,0 +1,101 @@ +# Free-running heads, one shared clock: `airport.h` + +`airport::loop_bank` is structurally the smallest kernel in the family — a +fixed array of loops, a stereo sum, no feedback anywhere — and that is what +makes it interesting to read: nearly every promise it makes is *structural*, +so nearly every test on it is bitwise. This appendix walks the file in code +order and dwells on the one discipline that defines it. + +## `loop_state`: the multitap idiom with a reel in each seat + +The bank is `std::array` with an active count — +`delay.h`'s multitap shape, kept deliberately: per-index setters that +silently no-op on a bad index, getters that return safe defaults, newly +activated slots arriving at their stored settings. Each seat holds a +`tape::reel` (its own worst-case buy — eight 30-second reels is ~92 MB of +double tape, the family's largest allocation, stated in the header rather +than discovered in production), a `tape::wear` used as a playback shade, a +phase, a record flag, and three ramps (level, pan, darken). + +## The phase discipline + +The load-bearing sentence in the header is "the phase is NEVER reset": +recording starts wherever the head is, `set_loops` activates a loop with +its head wherever it last was, a splice re-wraps the head modulo the new +length without rewinding, and only `prepare()`/`clear()` — DSP restarts — +may rewind. The reason is musical: in "2/1" the free-run *is* the piece, +and any convenience reset (snap to zero on record, realign on length +change) would quietly delete the composition. The pinned scenario earns the +promise the blunt way: it fires a setter storm mid-render — level, darken, +record, length, count — and then requires the click grid unmoved and the +head advanced by exactly the samples processed. `phase()` exists as +introspection precisely so that test could be written. + +## Record semantics + +`record` is a gate, not an action: while on, the input *replaces* the tape +at the integer head position, after the read — so you hear the previous +generation under the head while punching, and one Hermite support point +(two samples) of the old generation blends across the punch, which the +header files under honest limits instead of papering over with a crossfade. +No overdub-sum, because the provenance had none: each Airports phrase was +recorded once. Freeze is the strong promise — record off, and two +successive passes of the loop are required bit-identical. That promise is +only possible because of the next decision. + +## The shade and its bypass + +Per-loop `darken` reuses `tape::wear` with drive pinned at 0, as a *static +playback tone* — deliberately not generation loss, because a frozen loop +replays the same magnetic imprint every revolution and modeling wear on it +would be dishonest physics. At the band ceiling (the default) the stage is +bypassed entirely: not "flat enough", but not-in-the-signal-path, which is +what upgrades the freeze test and the hard-pan test (a pan of −1 adds the +loop's samples to the left bus unscaled) from tolerance checks to bitwise +facts. Engaged, the shade is the exact one-pole from grm_comb.h, and the +notebook measures a 6 kHz phrase through a 1 kHz shade at 0.169 of its +transparent twin against 0.169 predicted. + +## `composite_period_seconds` + +The lcm of the active loop lengths in samples, folded pairwise with a +`long long` gcd, overflow detected before each multiply and reported as ++inf. It is introspection, not DSP — but it is the piece's thesis as a +number: 24000- and 30000-sample loops report exactly 2.5 s (and the pinned +scenario also proves the rendered output repeats at 120000 samples and +does *not* repeat at 60000), while seven airport-scale lengths overflow to +infinity, which the header calls the point. + +## A finding: the raster before the assertion + +The lcm scenario existed as an assertion first — bitwise equality of two +2.5-second windows — and it passed, which is exactly why it was worth +plotting. The notebook's event raster (every return of loop A, loop B, and +their sum on one timeline) made the same fact *visible*: the coincidence +pattern audibly and graphically re-enters at 2.5 s and drifts everywhere +short of it. The assertion pins the promise; the raster is what convinces a +human the promise means something. The pair — one bitwise test, one +executed figure — is this library's preferred way to hold a structural +claim from both sides. + +## The engineering ledger + +Almost everything here is exact, so the suite asserts exactly: bit-equality +for freeze and for the lcm window, bitwise silence on the far bus for hard +pans, `phase()` continuity to 1e−9 through the setter storm, and the splice +law (0.9 of a 1 s loop re-wraps to 0.8 of a 0.5 s loop, never zero). The +one measured tolerance in the file is the shade's analytic transfer at 20%, +and the equal-power pan law needs no scenario of its own because the +multitap chapter already pinned the center at 1/√2 to 1e−12 — same code +shape, same law, cited rather than re-proven. Long-run behavior needs no +stability test at all: there is no feedback path to go wrong, which is +itself a fact the file's structure makes obvious enough not to test. + +## Checkpoint + +A fixed bank of reels, one sacred free-running head each; record replaces +and freeze is bitwise; splices re-wrap, never rewind; the shade bypasses to +bit-transparency at the ceiling; and the composite period is the score's +arithmetic made introspectable. The promises are structural, the tests are +bitwise, and the executed raster in `airport.ipynb` is the human-readable +proof that the structure composes. diff --git a/book/src/machine/garden.md b/book/src/machine/garden.md new file mode 100644 index 0000000..9264fec --- /dev/null +++ b/book/src/machine/garden.md @@ -0,0 +1,119 @@ +# Events, not audio: `garden.h` + +`garden::bed` recirculates *events* where its siblings recirculate samples, +which makes it the family's odd one out mechanically and its purest member +conceptually: the wear-as-stabilizer inversion survives the abstraction jump +intact, as arithmetic. This appendix walks the machinery — the ring, the +split between planting and firing, the bell, the quantizer, the gardener — +and the two contracts that had to be designed before they could be tested. + +## The event ring + +Sixty-four fixed seats (`std::array`, nothing allocated at `prepare()` — +this kernel buys no tape at all), each event a pitch, a velocity, a +brightness, a position on the loop, and a plant-order sequence number. The +sequence number exists for one policy: when the garden is full, the *oldest +live* bloom yields to a new plant. The musical argument is stated in the +header — a touch must always speak (rejecting input makes an instrument +feel dead), and the oldest bloom has survived the most decay passes, so it +is the quietest thing on the table; retiring it is the least audible edit +available. The pinned scenario plants a distinctive high note, floods the +ring with sixty-four more, and requires the first note's pitch measurably +gone from the following pass. + +## Fire is not plant + +`note()` does *not* sound a voice. It quantizes, seats the event at the +loop's current position, and returns; the next `process()` sample finds the +event's position under the playhead and fires it. The first draft did both +— plant-and-fire in `note()` — and the loop fired it again one sample +later, a double-trigger that fell out of the design the moment firing +became the loop's exclusive job. One mechanism, two consequences: a plant +sounds one sample late (inaudible, documented), and every sounding of every +event goes through a single code path, which is what makes the return grid +a testable promise. After each fire the event blooms: velocity times +`decay`, brightness times `soften`, retire below `floor` — so a bloom lives +exactly `ceil(log(floor/velocity)/log(decay))` passes and the population +converges no matter the planting rate. That is the stability theorem, and +it is three lines of arithmetic instead of a saturator. + +## The bell + +Two-operator FM at a fixed ratio of 3 (Chowning 1973), amplitude from the +shared `tr808::decay_env`, modulation index `velocity · brightness · +k_index_max`. The ratio was a *test requirement* before it was an +aesthetic: an integer ratio keeps the spectrum harmonic, harmonic means the +YIN oracle reads the fundamental, and the scale-contract scenario — plant +off-scale pitches, require every sounded note on the scale within 20 cents +— only exists because the voice is honest to a pitch detector. Softening +maps to the index, so "purer every pass" is measurable as a Goertzel +trajectory: the 4f sideband fades return over return while the fundamental +holds. Steals re-aim: the pool's quietest bell gets `trigger()`ed with new +targets while its envelope and phases free-run, so a steal glides where a +reset would click; the `decay_env` was built for exactly this non-resetting +retrigger, one family over. + +## Quantize at entry + +The scale machinery is `tune.h`'s 12-bit pitch-class mask idiom — the +`make_mask` builder, the nearest-allowed search that never travels more +than a tritone — *copied with citation, not included*, because `tune.h` +reaches into `tap::dsp` for its detector and a garden should not link a +pitch tracker to hold five scale presets. The masks themselves are plain +public-domain scale theory, deliberately not any app's preset list. +Quantizing at entry (rather than at fire) is the semantic choice: a scale +change re-pitches nothing already planted, which keeps running gardens +stable under live tinkering and makes the contract easy to state. + +## The gardener and the seed + +Idle planting consumes the family RNG (`tr808::white_noise`, xorshift64*, +the seed-folding and clear-reseeds contract) — and *only* idle planting +does. That consumption discipline is load-bearing: the third leg of the +seeded triad, "with the gardener disabled the seed cannot matter at all", +is only true because a disabled gardener never touches the generator, so +two beds with different seeds run bit-identical until the first idle draw. +The suite pins all three legs, the way the tr808 voices taught: same seed +bit-exact, different seed audibly different, seed irrelevant when the +random feature is off. `step_seq.h` promises "no randomness anywhere"; this +kernel is the deliberate counterpoint, and the triad is the bridge back to +a reproducible test suite. + +## A finding: envelopes never reach zero + +The return-grid scenario was first written the obvious way — the percussive +test bell surely dies between returns, so the first nonzero sample after +silence is the onset. It failed, instructively: `decay_env`'s exponential +tail crosses the 1e−12 hard-zero more than half a second after a "20 ms" +decay, so there *is* no silence between returns, only −200 dB of not-quite. +The fix was to stop pretending: an instant-attack bell, an amplitude +threshold scaled to the expected return velocity, and a grid claim of +"within 8 samples" — a sixth of a millisecond — with the comment explaining +that a threshold on a sine sits a few samples into the cycle. The lesson is +general for this library: exponential envelopes make "silence" a tolerance, +and tests that assume literal zeros between notes are wrong even when they +pass. + +## The engineering ledger + +The suite measures the output, never the internals: peak-per-window ratios +for the decay staircase (0.5 ± 0.075 across four returns, then +`active_events() == 0` and the render below 1e−6), a strictly-decreasing +Goertzel sideband for softening, YIN for the scale contract, the seeded +triad rendered three times over, and structural bounds exercised at their +edges — sixty-five plants against sixty-four seats, thirty-two notes +against sixteen bells, finiteness and the `k_voices` amplitude bound under +sustained stealing. The two introspection counts (`active_events`, +`active_voices`) exist, as `phase()` does next door, so those scenarios +could be written against public surface. + +## Checkpoint + +A fixed ring of events fired by a loop counter into a fixed pool of FM +bells: plant and fire kept strictly apart, wear as per-pass arithmetic +(decay, soften, floor) with convergence as its theorem, scale masks copied +from `tune.h` and applied at entry, and a gardener whose RNG discipline +makes generative behavior compatible with a bit-exact test suite. Third +costume, same inversion: the system stays bounded because everything in it +is always fading. Every claim lives twice — `garden.ipynb` executed, +`garden_test.cpp` pinned. diff --git a/book/src/machine/tape.md b/book/src/machine/tape.md new file mode 100644 index 0000000..4de70ba --- /dev/null +++ b/book/src/machine/tape.md @@ -0,0 +1,120 @@ +# Wear as the stabilizer: `tape_loop.h` and `discreet.h` + +Every regenerating loop in this library before these files made the same +promise the same way: the loop is strictly contractive because feedback is +capped below one (`delay.h`'s `k_fb_max = 0.99`, the comb bank's calibrated +ring time). `tape_loop.h` and `discreet.h` exist to make the opposite +promise — regeneration at exactly 1.0, bounded anyway — and this appendix is +the derivation of why that is allowed. + +## A shared header, by the house rule + +The family needed the same four pieces twice (`discreet.h` and `airport.h` +are both tape machines), and the reuse rule sorted them cleanly. Classes +with state went into a shared header the way `swing_vca.h` was created for +the drum family: `tape::reel`, `tape::wow_flutter`, `tape::wear`, and a +`tape::ramp` that is a cited copy of `delay.h`'s anti-zipper unit. Few-line +expressions stayed copies-with-citation, as ever: the Hermite polynomial +inside `reel` is *the same read as delay.h*, line for line, and says so; the +saturator is not copied at all but included — `vca::swing_shape`, the shared +swing-type stage, with the reason on the include line. + +## `reel`: one wrap, two topologies + +A reel is position-addressed circular storage whose reads and writes wrap +modulo a *settable loop length*, not the buffer size. That one decision lets +the same class serve both kernels. `discreet.h` runs it as a delay line: +loop length equals capacity, an integer write head advances forever (wrapped +into range each sample — a bare `long` head would overflow LLP64's 32-bit +`long` in half a day of audio), and the play head trails it by the loop +span. `airport.h` runs it as a true loop: length set per piece, one +free-running head, positions handed in raw because the reel does all modular +arithmetic itself. A length change is deliberately a *splice* — content +kept, positions re-wrapped — because that is what cutting tape does. + +## `wow_flutter`: periodic on purpose + +The transport error is two sines — slow-deep wow, fast-shallow flutter — +returning a read-position offset in samples, phases zeroed at `prepare()`. +The periodic term is the dominant one in the tape-echo literature +(Arnardóttir, Abel, Smith, AES 2008), but the deeper reason the stochastic +term is a documented non-goal is testability: the wow promise is pinned by +predicting peak pitch deviation in closed form (`depth · 2π · rate`, so 2 ms +at 0.5 Hz ⇒ ±10.9 cents) and measuring it with the YIN oracle — 10.9 +measured — and that oracle test only exists because two renders are +bit-identical. Determinism was a design force here, not an afterthought. + +## `wear`: the boundedness argument + +One pass of generation loss is three stages in fixed order: an exact +one-pole darkening lowpass (`1 − e^(−2πf_c/sr)`, the grm_comb.h map), the +shared saturator `swing_shape(v, d) = tanh(d·v)/d`, and the normalized DC +blocker. Each carries one clause of the proof: + +- `tanh` is bounded, so for any drive `d > 0` the wear output can never + exceed `1/d` — whatever the loop has accumulated. That is BIBO stability + at regen 1.0, unconditionally, from the saturator alone. +- The DC blocker (pole 0.999, peak gain normalized to exactly 1 — the + normalization grm_comb.h earned the hard way, chasing a +0.2 dB/s swell) + kills the one frequency the lowpass would happily sustain forever with an + offset attached. +- The lowpass is strictly contractive above its corner and asymptotically + transparent below it — which is not a leak in the proof but the musical + contract: at drive 0 and regen 1.0 the sub-corner band sustains + indefinitely, cleanly. The header calls this the Frippertronics contract + and states it rather than hiding it. + +So where `delay.h` proves stability by gain, this family proves it by +*shape*: each pass survives because it is degraded. The pinned test drives +regen 1.0 for ten seconds of ring and asserts non-growth — never decay, +because decay would betray the contract just as surely as growth. + +## The doppler decision + +`discreet::machine` gives `loop_seconds` an ordinary ramp and does nothing +else, because nothing else is needed: moving a fractional read head *is* +tape-speed doppler. A 0.5 → 0.75 s glide over half a second reads back an +octave down mid-move (measured: 220 Hz, then re-lock within five cents) with +no discontinuity, since position is continuous even where its slope is not. +The rejected alternative — crossfading between two taps — would have hidden +the machine, and hiding the machine is the one thing this kernel is for. +The wow offset is clamped so the read can never cross the record head; at +absurd depths on short loops the transport flattens against the clamp +rather than wrapping, which the header files under honest limits. + +## A finding: the arithmetic agreed + +The per-pass wear transfer is fully analytic — `regen · |H_lp| · |H_dc|` on +the unit circle — so the notebook measured it the direct way: a two-tone +burst (300 Hz under the corner, 6 kHz over it) recirculated at drive 0, each +generation's tones read by Goertzel. Measured per-pass ratios: 0.292 and +0.890. Predicted: 0.292 and 0.890. Three decimals of agreement between a +rendering kernel and a formula derived independently in the test is the +cheapest kind of confidence this library knows how to buy, and both the test +(with 15% and 5% tolerance bands it never needs) and the executed notebook +carry the measurement. + +## The engineering ledger + +The suite leans on four instruments. Analytic transfers wherever the path +is linear (the per-pass darkening scenario asserts against the exact +formula, both tones, both directions — highs die faster *and* lows barely +fade, so the test cannot pass vacuously). Two-window RMS for long-run +claims, inherited from the comb bank's swell story: regen 1.0 rings ten +seconds and the late window may not exceed the early one. The YIN oracle +for anything with a pitch: wow depth in cents against the closed form, the +doppler glide and its re-lock. And bitwise assertions where the law is +exact: mix endpoints, the first echo returning as literally the recorded +impulse, two wow renders identical to the bit. The DC-step scenario checks +the blocker's actual job — a held offset at regen 1.0 does not accumulate +and the tail's mean returns below 0.02 — rather than a decay the contract +never promised. + +## Checkpoint + +One shared header, four blocks: a reel that wraps at the loop, a transport +that is two deterministic sines, a wear stage whose `tanh` bound *is* the +stability proof, and a cited copy of the house ramp. `discreet.h` composes +them into the two-machine loop where regeneration legally reaches 1.0, +loop moves are doppler because read heads are physical, and every claim is +carried twice — `discreet.ipynb` executed, `discreet_test.cpp` pinned.