diff --git a/book/PLAN-pitch-chapters.md b/book/PLAN-pitch-chapters.md new file mode 100644 index 0000000..8218f3c --- /dev/null +++ b/book/PLAN-pitch-chapters.md @@ -0,0 +1,150 @@ +# Plan — the pitch-correction chapters + +> **Status: drafted.** All three chapters are written and live in `src/` per the placement +> below (2026-07-22). This file remains as the drafting record, the plans-directory way. + +Planning document for the *Tools on Tap* chapters covering the 2026-07 pitch-correction work +(`tap.tune~`, `taptools/tune.h`, and the DspTap primitives `yin.h` / `psola.h` / `pvoc.h`). +Three chapters: one user-facing, two 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. + +## Placement in SUMMARY.md + +Insert a new part before the machine part (which becomes Part VII): + +```md +# Part VI — Staying in tune + +- [The note you meant](tune.md) + +# Part VII — The machine, file by file + ...existing entries... +- [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 two machine entries slot after `machine/seq.md`, keeping the part's file-by-file order +roughly chronological. `machine/pitch.md` covers headers that live in the DspTap repo — the +same cross-repo situation `machine/spectral.md` already handles for `fft.h`; follow its +convention (name the repo once, link the file, treat it as part of the machine). + +--- + +## Chapter 1 (user-facing) — *The note you meant* (`src/tune.md`) + +The chapter sells one image: the distance between the note you sang and the note you meant, +and a single time constant that decides how honestly to close it. Voice: the person patching +at 11 pm; every knob a trade. + +Outline: + +1. **The effect, and where it came from.** Real-time monophonic correction: detect, snap, + glide. One paragraph of history done carefully: the foundational 1998 patent expired in + 2018, so the classic pipeline is public domain — which is why the field exists; the famous + product name is a live trademark, which is why this object is called `tap.tune~`; and + polyphonic per-note editing remains fenced (and out of scope — this is a monophonic tool + by design, not by omission). Keep it two sentences per fact, no legal advice. +2. **One knob that is the instrument: `speed`.** Hard snap (0 ms) is the quantize effect; + ~20 ms is invisible repair; 200 ms only leans. Figure: the three-glide pitch-track plot. + *Evidence: `notebooks/tune.ipynb` §1; kernel scenario "retune speed sets the glide".* +3. **Telling it what's allowed.** Key + scale, the twelve per-note enables (`notes`), and + MIDI mode (the held-note targeting that turns the corrector into a hard harmonizer-ish + instrument). The empty-mask / no-notes-held behavior: no target, no correction — the + object never guesses. *Evidence: kernel scenarios for mask/MIDI targeting.* +4. **Three engines, one corrector: `backend`.** The user-level trade table (grain: cheapest, + waveform-preserving, default; psola: voice, formants for free; pvoc: dense material, + one-frame latency) and the latency ledger in milliseconds. All three land the same + intonation — figure: the vibrato-voice pitch-track overlay. Point forward to the machine + chapter for *why*. *Evidence: `tune.ipynb` §2 (all backends settle at 220.00 Hz).* +5. **Keeping the singer's mouth: `formant`.** When corrections are small it doesn't matter; + when MIDI mode commands a fifth, it does. Figure: the spectra overlay (bump stays at 960). + One honest sentence each on psola (needs no flag) and grain (unaffected). + *Evidence: `tune.ipynb` §3; pvoc formant tests.* +6. **Letting it find the key: `autokey`.** Learning-only by design — the estimate never + flips your targets mid-phrase; `getkey` asks, `applykey` adopts. The ~1-minute memory and + the half-second warm-up, stated as behavior ("it forgets old sections about as fast as + you move on from them"). *Evidence: kernel autokey scenarios (D major at 0.95).* +7. **The right outlet.** `pitch ` every `interval` ms — the free tuner display; + drive a number box, a scope, or your own harmonizer logic. +8. **When it is the wrong tool.** Chords (monophonic detector — and the polyphonic fence); + drums and speech consonants (unpitched input passes with a mild grain coloration — say + so); octave-plus creative shifts (reach for `tap.shift~`/`tap.pitchaccum~` instead). +9. **Companion material.** Help patcher, the maxtest, both notebooks, the machine chapters. + +## Chapter 2 (machine) — *Three ways to move a pitch: `yin.h`, `psola.h`, `pvoc.h`* +(`src/machine/pitch.md`) + +The appendix earns the two findings. Structure it as three short essays sharing one moral: +each algorithm is a claim about what a pitched sound *is*, and each claim fails somewhere +measurable. + +1. **A period is a lag that explains the signal: `yin.h`.** The difference function, the + cumulative-mean normalization (why τ=0 stops being a trap), the absolute threshold, the + parabolic sub-sample refinement. The contract numbers (worst sine error 0.17 cents; saw + octave-clean). The honest limit: first-dip-below-threshold on missing-fundamental + material picks subharmonics — shown deliberately with the notebook's formant-bump + synthetic, and why real voices don't trigger it. *Evidence: `test_yin.cpp`, + `pitchshift.ipynb` §1 (+ the §4 oracle footnote).* +2. **Finding 1 — a shifter that moves everything except the envelope: `psola.h`.** Grains, + marks, the 1/ratio window sum, sub-sample Hermite placement. Then the finding, told as it + happened: the octave-up sine "failure" (0.0000 peak) that is the algorithm working as + published — PSOLA resamples the spectral envelope, which is one property wearing two + faces (formant preservation on voice, silence on the tone the envelope abandoned). The + pinned `PureToneOctaveUpThinsOut` test as the moral: document the property, don't patch + it. *Evidence: `test_psola.cpp`, `pitchshift.ipynb` §2.* +3. **Finding 2 — the naive phase vocoder loses half its level: `pvoc.h`.** The textbook + `round(k·ratio)` remap measured (0.14–0.46 of unit level at fractional ratios) and the + two structural reasons; Laroche–Dolson peak-region rigid translation; and the subtle bug + worth a whole section: the integer shift's modulator is frame-relative, so ψ must + accumulate the FULL `f·(r−1)` — subtracting the integer part desynchronizes the + overlap-add. End on the contracts: ~0.95 level everywhere, sub-cent accuracy, identity at + ratio 1 exact to 7.8e-16. *Evidence: `test_pvoc.cpp`, `pitchshift.ipynb` §3.* +4. **The envelope as a filter: LPC formant preservation.** Autocorrelation method, + Levinson–Durbin in double, |A| via one FFT of the prediction polynomial, the + `env(target)/env(source)` per-bin trade, the boost clamp, and the identity invariance + (exactly unity when nothing moves). *Evidence: pvoc formant tests, `pitchshift.ipynb` §4.* +5. **The house pattern.** One paragraph: golden double model, float32 profile, fixed + contracts, hot loops as future MVE/HVX backend seams — the `fft.h` inheritance. + +## Chapter 3 (machine) — *The nearest allowed note: `tune.h`* (`src/machine/tune.md`) + +The composition appendix: how detector, mapper, glide, and three resynthesis engines share +one allocation-free object. + +1. **The pipeline and its clock.** Per-sample process, per-hop (~5.3 ms) analysis, the + worst-case-geometry-at-prepare trick that keeps every setter real-time safe, and the + analysis cost spike stated in numbers (and why it fits a 64-sample vector budget). +2. **The period lock, told as a bug hunt.** The 5-cent bias the oracle tests caught, the + isolation experiment (window = exact two periods → −0.06 cents; fixed-ms clamp → +5.4), + and the even-multiple rule that keeps the taps an integer number of periods apart. This + is the chapter's centerpiece — it is the cleanest example in the book of a *musical* + defect that only an oracle-based test could pin. *Evidence: the tune_test chromatic + scenarios; the debug numbers are in the git history of this branch.* +3. **Choosing the target.** Semitone geometry of the mask search (±6 always suffices), + MIDI-mode nearest-held-note, the correction clamp, `amount` as a fader on the distance. +4. **The glide.** One-pole on applied semitones, snap at zero, unpitched relaxation toward + no-correction — and why the *window* holds while correction relaxes. +5. **Three backends behind one seam.** What switching clears and why (silence, not splice); + the per-backend period plumbing (psola's slewed period input); the latency ledger. +6. **Learning the key.** The leaky histogram (60 s memory), the mass guard, Pearson vs the + Krumhansl–Kessler profiles, and the design decision that it never acts on its own — + stated as a UI-safety argument, not modesty. *Evidence: autokey scenarios.* +7. **The ledger.** The test strategy paragraph the machine chapters share: the DspTap yin as + oracle, saw-not-sine for PSOLA fairness, notebook cross-checks, and what the maxtest pins + in a real Max. + +--- + +## Notes for drafting + +- Chapter titles follow the book's voice (image first, filename in the machine part). + Alternates considered for ch. 1: "Staying in tune", "The snap and the glide". +- The IP paragraph in ch. 1 stays engineering-orientation prose, mirroring REVIVAL.md §12; + the ship-gate (attorney freedom-to-operate pass) belongs there, one sentence, no drama. +- Figures come straight from the two executed notebooks; regenerate rather than screenshot. +- Cross-repo linking: `machine/pitch.md` names the DspTap repo once at the top (the + `machine/spectral.md` precedent) and links files on GitHub thereafter. diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md index df9443f..46d7d66 100644 --- a/book/src/SUMMARY.md +++ b/book/src/SUMMARY.md @@ -29,7 +29,11 @@ - [The acid machine](acid.md) - [The drum machine](drums.md) -# Part VI — The machine, file by file +# Part VI — Staying in tune + +- [The note you meant](tune.md) + +# Part VII — The machine, file by file - [Solving the filter on paper: svf.h](machine/svf.md) - [The nonlinear loop: ladder.h](machine/ladder.md) @@ -44,3 +48,5 @@ - [The couplings are the instrument: tb303_voice.h](machine/tb303.md) - [One network, eight voices: the tr808 headers](machine/tr808.md) - [Time as a function of phase: step_seq.h](machine/seq.md) +- [Three ways to move a pitch: yin.h, psola.h, pvoc.h](machine/pitch.md) +- [The nearest allowed note: tune.h](machine/tune.md) diff --git a/book/src/machine/pitch.md b/book/src/machine/pitch.md new file mode 100644 index 0000000..c9ffb39 --- /dev/null +++ b/book/src/machine/pitch.md @@ -0,0 +1,176 @@ +# Three ways to move a pitch: `yin.h`, `psola.h`, `pvoc.h` + +The [user-facing chapter](../tune.md) promised that three interchangeable +engines land the same intonation. This appendix is about why that is hard: +each engine is a *claim about what a pitched sound is*, and each claim fails +somewhere specific and measurable. Two of those failures were found the good +way — as failing tests during development — and both are now pinned as +contracts rather than patched into vagueness. + +These three headers live in the shared **DspTap** repository (the same home +as the real FFT that `machine/spectral.md` describes), because a pitch +detector and two shifters are not Max material or even TapTools material — +they are primitives, in the `fft.h` mold: a double-precision golden model, +a float32 embedded profile pinned against it, allocation-free `noexcept` +processing, fixed documented latency, and hot loops kept contiguous as +future Helium/HVX backend seams. Every number below is produced by the +shipping code through DspTap's C ABI in `notebooks/pitchshift.ipynb`, and +gated in `test_yin.cpp` / `test_psola.cpp` / `test_pvoc.cpp`. + +## A period is a lag that explains the signal: `yin.h` + +Autocorrelation says: a signal is periodic at the lag where it best matches +itself. The trouble is that a harmonic-rich signal matches itself *rather +well* at twice the true period too, and "rather well" wins often enough to +make naive autocorrelation an octave gambler. YIN (de Cheveigné & Kawahara, +2002) replaces "best match" with "smallest failure": a squared **difference** +function + +``` +d(τ) = Σ (x[j] − x[j+τ])², j over the integration window +``` + +then divides each lag's failure by the running mean of all failures up to +that lag — the *cumulative-mean normalization* — so `d′(0) ≡ 1` and small +lags stop being free wins. The detector takes the **first** lag whose +normalized failure dips under an absolute threshold (0.1 by default), +descends to the local minimum, and refines it with a parabolic fit over the +three surrounding values — the sub-sample step that turns an integer lag +grid into a fractional period. + +The contract, measured: worst sine error 0.17 cents across 82–988 Hz +(including deliberately non-integer periods), worst sawtooth error 0.155 +cents *with no octave errors* — the trap the normalization exists to +disarm. Noise and silence report unvoiced, and the threshold gates honestly +(a deliberately dirtied sine flips to unvoiced when the threshold is +tightened below its measured aperiodicity). + +One honest limit, kept on purpose: *first dip under threshold* scans from +short lags to long, so on synthetic material whose fundamental is nearly +absent — a formant bump with almost no energy at f₀ — a subharmonic lag +that happens to land on an exact integer can dip deeper than the true +period's slightly-off-grid dip, and the detector follows it. The notebook +demonstrates this deliberately and measures such material with a cepstral +oracle instead. Real voices keep enough fundamental that the rule holds; +the failure is documented, not hidden. + +## Finding 1 — a shifter that moves everything except the envelope: `psola.h` + +TD-PSOLA's move is disarmingly physical. Put an analysis mark every period. +Cut a two-period Hann grain around each mark. To synthesize a new pitch, +lay the grains back down at a *new* spacing — period/ratio — and sum. The +windows are arranged to sum to one at the identity, grains are scaled by +1/ratio to keep the sum flat elsewhere, and synthesis marks are placed with +sub-sample precision (each grain resampled through the same 4-point Hermite +kernel the rest of the family uses) so mark rounding never becomes pitch +jitter. The file adds one real-time honesty: marks come from a free-running +period-synchronous scheduler, not glottal-epoch estimation — the standard +practical simplification — and the caller supplies the period, so detector +and shifter stay independently testable. + +Then the finding, told as it happened. The first shift-accuracy test fed the +shifter a pure sine at ratio 2 and got back **0.0000** — silence, from a +correct implementation. Because that *is* what PSOLA does: re-spacing +period-synchronous grains resamples the source's **spectral envelope** at +the new harmonic spacing. A voice's envelope is wide — formants — so the +new harmonics sample it fine, which is exactly the celebrated property: +formants stay put while pitch moves. A pure sine's envelope is a single +spike at f₀, and after an octave up the new harmonic grid (2f₀, 4f₀, …) +contains nothing at f₀ — the output honestly, correctly vanishes. One +property, two faces. + +The response was not to patch the algorithm into something less itself. The +shift tests were rewritten onto voice-like material (a normalized +band-limited sawtooth: ±8 cents across ratios 0.5–2.0 at healthy level), +and the pure-tone behavior got its own pinning test, +`PureToneOctaveUpThinsOut`, so that if this property ever *changes*, someone +is forced to explain why. The header now opens with the warning label: +know what PSOLA is; feed it harmonics; for pure tones use a +waveform-preserving shifter. + +Latency is fixed at `2·max_period + 2` samples — the price of grains that +must be fully received before they can be laid back down. + +## Finding 2 — the naive phase vocoder loses half its level: `pvoc.h` + +The textbook pitch shifter looks like four honest lines: STFT with Hann +windows at 4× overlap; per-bin instantaneous frequency from the +frame-to-frame phase increment; remap each analysis bin `k` to synthesis +bin `round(k·ratio)`; accumulate each synthesis bin's phase at its scaled +frequency and inverse-transform. It is in tutorials everywhere. Measured on +a unit sine, it delivers **0.14–0.46 of the input level** at fractional +ratios — more than half the signal simply gone — and its "identity" at +ratio 1 is a sine of the right frequency with the wrong waveform. + +Two structural reasons. First, a single partial does not live in one bin; +it lives in a Hann mainlobe *pattern* across four-ish bins, and +`round(k·ratio)` scatters that pattern (220 Hz × 1.5 lands on bins +{5, 6, 8, 9} — nothing at the true target, 7.04). Second, free-running +per-bin phase accumulators destroy the phase relationships across the lobe, +and the overlap-add — which is a resampling filter with real opinions — +partially cancels what remains. + +The shipping design is Laroche–Dolson peak-region shifting. Find the +spectral peaks (local maxima over ±2 bins, gated 80 dB below the frame's +strongest bin so the noise floor cannot claim regions). Split the spectrum +into regions around them. Translate each region **rigidly** by an integer +bin offset — the lobe pattern survives intact, phase relationships and +all — and rotate the whole region by a single accumulated per-hop phase ψ. + +And here is the bug that cost an afternoon and earned its own comment +block: ψ must accumulate the **full** per-hop frequency difference, +`ψ += 2π·hop·f·(r−1)/N`, not the sub-bin residual left after the integer +shift. An integer bin shift is implemented, in effect, by a modulator +`e^(2πi·shift·n/N)` — but `n` is the *frame-relative* sample index, so that +modulator restarts every frame and contributes nothing to frame-to-frame +phase advance. Subtract the shift from ψ (the "obvious" refinement) and +every frame disagrees with the last about where the shifted partial's phase +should be; the overlap-add quietly shreds the signal. With ψ carrying the +full difference, the measured contracts land: sub-cent frequency accuracy +at every tested ratio, ~0.95 level everywhere, and — because at ratio 1 +every shift and every ψ increment is exactly zero and the analysis phases +pass straight through — **exact** waveform identity, one frame late, to +7.8 × 10⁻¹⁶. + +### The envelope as a filter: LPC formant preservation + +`set_formant(true)` adds the classic source-filter correction. Per analysis +frame: autocorrelate the windowed time frame to lag 48, run Levinson–Durbin +(always in double — an order-48 recursion in float32 is not a place to +economize), and evaluate the prediction polynomial's magnitude over all +bins with one extra FFT of its coefficients — the same transform engine, +one more call. That gives a spectral envelope `E(k) = 1/|A(e^jωk)|`, and +every relocated bin trades envelopes: content moving from bin `k` to bin +`j` is scaled by `E(j)/E(k)` (clamped to ±24 dB so a near-zero envelope +cannot mint gain). The excitation moves; the envelope stays. Measured: a +synthetic 800 Hz formant on a shifted-up-a-fifth voice stays at 800 Hz +with the flag on (band-energy ratio 62:1) and dutifully chipmunks to +1200 Hz with it off. At ratio 1 the correction is `E(k)/E(k)` — exactly +unity — so the identity contract survives the feature untouched. The +method is implemented from the published literature only, which in this +corner of DSP is a policy statement, not just a citation habit. + +## The house pattern + +All three files repeat the `fft.h` discipline because it keeps paying: +`basic_*` templates with `double` as the golden model and `float` +as the embedded profile, cross-precision agreement pinned by tests; +geometry fixed at construction and every buffer allocated there; +`noexcept`, allocation-free processing; latency as a number in the header, +not a vibe; and the expensive inner loops (YIN's difference function above +all) written as plain contiguous arithmetic so a Helium or HVX backend can +slot in behind the same contract with the scalar build remaining the +oracle. + +## Checkpoint + +A detector that measures failure-to-match instead of match, normalized so +short lags stop cheating, refined below the sample grid — sub-cent, octave- +safe, honest about the one synthetic that fools its first-dip rule. A +grain shifter whose deepest property — resampling the spectral envelope — +is both its celebrated feature and its pure-tone failure, pinned from both +faces. A phase vocoder that works *because* peaks move as rigid families +with one phase register each, carrying the full frequency difference — +since the integer shift's modulator restarts with every frame. And an LPC +envelope trade that lets the excitation move while the mouth stays. Three +claims about what a pitched sound is; three sets of receipts. diff --git a/book/src/machine/tune.md b/book/src/machine/tune.md new file mode 100644 index 0000000..e465701 --- /dev/null +++ b/book/src/machine/tune.md @@ -0,0 +1,168 @@ +# The nearest allowed note: `tune.h` + +The [pitch-primitives appendix](pitch.md) built the parts: a detector and +two shifters, each with a numeric contract. This appendix is about the +composition — `tap::tools::tune::corrector`, the object behind +`tap.tune~` — where the interesting problems are not algorithms but +*policies*: what runs when, what is allowed to allocate, what happens when +the detector reports nothing, and one measured surprise that became the +kernel's best war story. The scenarios in `tune_test.cpp` drive the class +directly, using the DspTap detector as an independent pitch oracle on the +output; `notebooks/tune.ipynb` re-measures the headline claims through the +C ABI. + +## The pipeline and its clock + +`process()` runs per sample; analysis runs per hop (256 samples at 48 kHz, +about 5.3 ms, scaled with the rate). Each sample: feed the detector's input +ring, maybe analyze, advance two slews (the applied correction and the +grain window), compute the ratio, resynthesize. + +The geometry trick that keeps every setter real-time safe: the detector is +built at `prepare()` for the *worst case* — lags from 2 kHz down to 55 Hz — +and the user's `set_range()` merely filters results afterward, treating +out-of-range estimates as unvoiced. Changing the range never reallocates, +so it is safe mid-audio, and the price is a fixed analysis cost: with +window = τ_max = 873 samples at 48 kHz, the YIN difference function is +roughly 760k multiply-adds per analysis — an ~80 µs scalar spike every +5.3 ms, well inside a 64-sample vector's 1.3 ms budget, and the +FFT-accelerated difference function remains available behind the same +contract if an embedded target ever objects. + +Analysis converts the detected period to MIDI, chooses a target +(next section), sets the correction goal in semitones, and retargets the +grain window. Unpitched frames set the correction goal to zero — the +corrector *relaxes* toward honesty — while the window holds its last value +rather than lurching toward a default. + +## The period lock, told as a bug hunt + +The first version of the resynthesis stage was the two-tap `tap.shift~` +engine with its grain window clamped to a sensible fixed range, minimum +5 ms. The oracle tests immediately failed — not wildly, *musically*: a +452 Hz input hard-snapped to A440 came out at 441.4 Hz, 5.4 cents sharp. +Detection was exonerated first (0.06 cents), then the applied correction +(right to five decimals). The bias lived in the shifter itself, and an +isolation experiment found the shape of it: + +| grain window | measured output | error | +|---|---|---| +| exactly 2 detected periods (212.4 smp) | 439.98 Hz | −0.06 cents | +| fixed clamp (240 smp) | 441.38 Hz | +5.41 cents | +| 480 smp (≈4.52 periods) | 441.36 Hz | +5.34 cents | + +The two taps ride the same phasor half a cycle apart, so they sit +window/2 samples apart in the delay line. When window/2 is an integer +number of source periods, the taps read *the same phase* of the waveform +and their crossfade is invisible — and the average retune ratio is exactly +the phasor's ratio. When it isn't, every crossfade splices a phase jump +into the output, and the jumps do not average away: they bias the pitch. +Period-locking the window is not a quality nicety; it is what makes the +ratio true. + +The fix: the window targets the smallest **even multiple** of the detected +period that clears the minimum — 2 periods normally, 4 for high pitches +whose 2 periods would be under 5 ms — so the taps always sit an integer +number of periods apart. The clamp survives only as an outer bound. This is +the cleanest example in the book of a defect no assert-on-internals test +would ever catch: only an oracle — the detector listening to the *output* — +could hear 5 cents. + +## Choosing the target + +Scale mode: round the detected MIDI to a center note, then scan offsets +−6…+6 for enabled pitch classes, keeping the candidate nearest to the +*fractional* detected pitch (ties resolve to the smaller motion). A tritone +of search radius suffices for any non-empty mask; an empty mask returns no +target, and no target means a zero correction goal — the object never +guesses. MIDI mode is simpler and blunter: the nearest currently-held note +in absolute MIDI space, whatever the distance (clamped to ±12 semitones of +actual correction). `amount` scales the goal before the glide — a fader on +the distance itself. + +## The glide + +The applied correction chases its goal through a one-pole with time +constant `speed` (0 = assignment, the hard snap), evaluated per sample so +the goal can move every hop while the glide stays silky. The ratio is then +`2^(applied/12)`, computed per sample; the exp2 is cheap and the +alternative — caching with edge cases — is not. The grain window rides its +own 15 ms slew toward the period-locked target, and the detected period +gets a third slew for the PSOLA backend's per-sample period input. Three +small slews, no zippers, no special cases at the joins. + +## Three backends behind one seam + +`set_backend()` swaps only the last stage; detector, mapper, and glide are +shared state that survives the switch. Both alternate engines are +constructed at `prepare()` (PSOLA sized to the deepest detectable period, +the phase vocoder's FFT scaled to ~21 ms at any rate), so switching +allocates nothing and is safe mid-audio; the incoming engine is cleared to +silence first — a fade-in, not a splice of stale buffers. The ledger, at +48 kHz: + +| backend | resynthesis | latency | +|---|---|---| +| grain | period-locked two-tap (in-kernel) | ≈ base delay + window/2, a few ms | +| psola | `tap::dsp::psola` | 2 × 873 + 2 = 1748 samples ≈ 36 ms | +| pvoc | `tap::dsp::pvoc` (+ optional LPC formant trade) | 1024 samples ≈ 21 ms | + +The backend-parametrized scenarios feed all three the same 46-cent-sharp +sawtooth and require the same landing (±6 cents at healthy level); a +switching scenario hops between engines mid-signal and requires finite +output and a correction that is still standing at the end. `set_formant()` +forwards to the phase vocoder — PSOLA preserves formants by construction +and the grain engine is waveform-preserving, so the flag deliberately +touches one path. + +## Learning the key + +The auto-key learner is thirteen doubles and a policy. Every voiced +analysis adds 1 to its pitch class's histogram bin; every analysis +multiplies all twelve bins by a leak chosen so the histogram forgets with +a 60-second time constant. On demand — never on a schedule — the histogram +is scored by Pearson correlation against the published Krumhansl–Kessler +major and minor profiles at all twelve rotations, and the best of the 24 +becomes the estimate, with the winning correlation as confidence. A mass +guard withholds any estimate until roughly half a second of voiced material +exists, so silence cannot have an opinion. + +The design decision that matters is that the learner is *advisory*: +`autokey_estimate()` reports and `autokey_apply()` adopts, but nothing in +the audio path ever re-aims the targets on its own. This is a UI-safety +argument, not modesty — a corrector that changes its own scale mid-phrase +turns a wrong estimate into a wrong *performance*, and the person at the +patch cannot undo what they never saw happen. Measured: a tonic-weighted +D-major scale scores D major at 0.95 confidence; an A harmonic-minor +melody scores A minor; reset withdraws the estimate. + +## The ledger + +- **Allocation discipline.** Everything sized at `prepare()`: detector + frame and ring, both alternate backends, the grain buffer at the maximum + window. After that the audio path allocates nothing; every setter either + writes a double, flips a flag, or clears preallocated state. +- **Oracle-based testing.** The scenarios measure the *output's* pitch with + the independently-certified DspTap detector — the only kind of test that + caught the period-lock bias — and use sawtooth, not sine, wherever PSOLA + participates, per its documented material contract. +- **The maxtest.** One assertion runs inside a real Max: unpitched DC in, + exactly DC out — detector unvoiced, correction zero, complementary + envelopes summing to one. It pins the whole "never guess" policy at + unity gain in the shipping binary. +- **What the wrapper adds.** Only plumbing: attribute forwarding, the + atomic pitch handoff to a scheduler timer for the right outlet, and + `applykey` writing back through the *attributes* so Max's saved state + stays the source of truth. + +## Checkpoint + +A per-sample corrector with a per-hop brain: worst-case geometry bought at +`prepare()` so nothing ever allocates again, unpitched input relaxing to +zero correction, and three slews smoothing every join. The war story is the +period lock — two taps half a window apart are only honest when that +half-window is an integer number of periods, and only an oracle test could +hear the 5-cent lie. Targets are chosen, never invented; the glide is one +pole and one exp2; the backends swap behind a seam that clears to silence; +and the key learner watches, scores, remembers for a minute — and speaks +only when spoken to. diff --git a/book/src/tune.md b/book/src/tune.md new file mode 100644 index 0000000..44dea64 --- /dev/null +++ b/book/src/tune.md @@ -0,0 +1,162 @@ +# The note you meant + +Every sung note is two notes: the one that happened and the one you meant. +`tap.tune~` measures the distance between them and closes it — how fast it +closes it is the whole instrument. Closed slowly, nobody knows it was there. +Closed instantly, everybody knows: that snap *is* the most famous vocal +effect of the last twenty-five years. One object, one time constant, both +worlds. + +A short history matters here, told plainly. The classic pipeline — detect +the pitch, snap it to the nearest allowed note, retune by time-domain +resynthesis — was patented in 1998 and the patent expired in 2018, which is +why a whole field of tuners exists today and why this object can implement +the technique from the literature. The famous product *name* remains a live +trademark, which is why this object is called `tap.tune~` and this chapter +says "hard snap" instead. And editing individual notes *inside a chord* +remains patent-fenced territory — `tap.tune~` is monophonic by design, not +by omission. (None of this paragraph is legal advice; the project's own +ship-gate is a freedom-to-operate review.) + +Companion material: the reference page and help patcher in the TapTools-Max +package, the runtime maxtest, and two executed notebooks — `tune.ipynb` +here and `pitchshift.ipynb` in the DspTap repo — that measured every claim +below. + +## The knob that is the instrument: `speed` + +`speed` is the time constant, in milliseconds, of the glide onto the target +note. + +- **0 ms** — the hard snap. The correction lands within a detection hop + (~5 ms). Vibrato gets quantized into terraces; note transitions become + instant staircase steps. This is the effect, worn on the outside. +- **10–40 ms** — classic correction. Fast enough that a listener hears "a + singer with good intonation," slow enough that the attack of each note — + where identity lives — is not robotic. The default is 20. +- **100 ms and up** — intonation *leaning*. The corrector arrives so late it + only tames drift; vibrato passes through nearly untouched. + +The notebook's pitch-track figure shows all three glides onto the same +46-cent-sharp note; the kernel test pins the exponential's arrival. There is +also `amount` (0–100%): a fader on the correction distance itself. 100 +lands on the target; 50 splits the difference — a gentler kind of honesty +that keeps a performance's shape while shrinking its errors. + +## Telling it what is allowed + +The corrector never invents a target; it snaps to the nearest note *you +allowed*. + +- **`key` + `scale`** — the usual contract: `@key d @scale major` and every + detected pitch pulls toward the nearest D-major degree. Presets: + chromatic, major, minor, harmonic, melodic, pentatonic, minorpentatonic. +- **`notes`** — the twelve toggles, absolute pitch classes C through B, + panel-style: `notes 1 0 0 0 1 0 0 1 0 0 0 0` snaps everything to a + C-major triad, which is less a correction than an arrangement decision. +- **`mode midi`** — the target is the nearest *currently held* MIDI note + (`note 64 100` holds E4; velocity 0 releases; `flush` clears). Hold one + note and everything becomes that note; hold a changing chord's roots and + the corrector is suddenly a performable melody-mangler. No notes held + means no correction — the object never guesses. + +An empty mask behaves the same way: nothing allowed, nothing changed. + +## Three engines, one corrector: `backend` + +Detection, targeting, and the glide are shared; only the resynthesis swaps. +All three land the same intonation — the notebook drives the same vibrato +"voice" through each and all three settle on 220.00 Hz — so the choice is +about character and latency, not accuracy. + +| backend | what it is | choose it for | latency @ 48 kHz | +|---|---|---|---| +| `grain` | two-tap delay-line, window locked to the detected period (the `tap.shift~` engine) | the default; lowest latency, waveform-preserving, happy on any material | a few ms | +| `psola` | true TD-PSOLA | voice — it preserves formants by construction | ~36 ms | +| `pvoc` | peak-locked phase vocoder | dense, harmonically rich material; pairs with `formant` | ~21 ms | + +Switching live is click-safe: the incoming engine starts from silence and +fades in rather than splicing stale audio. One honest caveat per engine: +`grain` colors sustained *unpitched* input with a mild moving comb (the +known trade of its class); `psola` wants harmonic material — on a pure +sine shifted far, its output legitimately thins (the machine chapter +explains why that is the same property as its formant preservation); +`pvoc` smears sharp transients slightly, as every phase vocoder does. + +## Keeping the singer's mouth: `formant` + +A correction of thirty cents moves formants thirty cents — nobody hears it. +A MIDI-mode command of five semitones moves them five semitones — everybody +hears it; that is the chipmunk. `@formant 1` enables LPC formant +preservation on the `pvoc` backend: the pitch moves, the vocal tract's +envelope stays where the singer put it. The notebook corrects a synthetic +voice up 5.5 semitones both ways; with the flag on, the formant bump stays +put (band-energy ratio 730:1 in its favor). `psola` needs no flag — formant +preservation is its resampling rule — and `grain` ignores the flag. + +## Letting it find the key: `autokey` + +`@autokey 1` starts a learner: every voiced detection drops its pitch class +into a histogram that forgets with about a minute of memory, scored against +the published Krumhansl–Kessler key profiles. Two design decisions worth +knowing: + +- **It never acts on its own.** A key estimate that silently re-aimed your + targets mid-phrase would be a bug wearing a feature's clothes. `getkey` + asks (the right outlet answers `key d major 0.95`, or `key none` in the + first half-second); `applykey` adopts the estimate into the `key` and + `scale` attributes — visibly, where you can see and undo it. +- **It forgets on purpose.** The one-minute memory means a modulation stops + arguing with the old verse about as fast as you stop playing it. + +The kernel test plays a D-major scale and reads back D major at 0.95 +confidence; an A harmonic-minor melody reads as A minor. + +## The right outlet + +While the input is voiced, the right outlet reports +`pitch ` every `@interval` milliseconds (default 50; 0 disables; +a `pitch -1 0` marks the end of voicing). That is a free tuner display, a +melody recorder, or the control signal for whatever you want to drive with +the singer's pitch — and it is the same detector the corrector itself uses, +so what you see is what it acted on. + +## Recipes + +- **Invisible repair:** `@scale major @key` (your key) `@speed 25 + @amount 80`. The 80 keeps a little humanity in the intonation; nobody + will name what changed. +- **The famous one:** `@speed 0 @scale minorpentatonic`. Fewer allowed + notes make the terraces wider and the snap prouder. Add melisma. +- **One-note choir:** `@mode midi @speed 5`, hold a note, feed it speech. + Everything becomes chant on that pitch. +- **Formant-true transposer:** `@mode midi @backend pvoc @formant 1 + @speed 10`, play a melody against a held vocal — a harmonizer that keeps + the singer's identity. +- **Tuner display only:** `@amount 0 @interval 20` — the object corrects + nothing and the right outlet becomes a clean pitch stream. + +## When it is not the right tool + +- **Chords.** The detector is monophonic; a chord reads as garbage or as + its loudest note, and per-note polyphonic editing is deliberately out of + scope (see the history paragraph). Split voices first, or don't. +- **Drums, breath, speech consonants.** Unpitched input passes through with + no correction — by design — but the grain engine adds its mild comb + coloration to sustained noise. For processing unpitched material there + are better rooms in this house. +- **Creative shifting.** If the goal is *an interval* rather than + *intonation*, `tap.shift~` is the plain shifter and `tap.pitchaccum~` + the spiral; `tap.tune~` always measures first and that measurement is + latency you don't need. + +## Checkpoint + +Detect, snap to the nearest allowed note, glide at `speed` — that is the +whole machine, and `speed` is the dial between honesty and effect. Targets +come from key + scale, twelve toggles, or held MIDI notes; three resynthesis +engines trade character against latency while landing the same intonation; +`formant` keeps the singer's mouth in place when corrections get big; +`autokey` learns the key but only ever suggests. The right outlet tells you +what it heard. And when the input isn't a single pitched voice, the honest +move — which the object makes — is to change nothing. diff --git a/include/taptools/tune.h b/include/taptools/tune.h new file mode 100644 index 0000000..bac8330 --- /dev/null +++ b/include/taptools/tune.h @@ -0,0 +1,651 @@ +/// @file +/// @brief Portable pitch-correction kernel for tap.tune~ — no Max/Min dependency. +/// @details Classic real-time monophonic pitch correction: detect the input's period, snap it to +/// the nearest allowed note, and retune by that ratio — with the retune speed (the time +/// constant of the glide toward the target) as the primary musical control, from +/// transparent correction down to the hard-snap effect at zero. +/// +/// The pipeline is the public-domain design (the foundational 1998 patent expired in +/// 2018): a YIN-family detector (the shared DspTap primitive, tap::dsp::yin — full-rate, +/// cumulative-mean normalized, parabolic sub-sample lag) feeds a scale/key mapper, and a +/// two-tap delay-line transposer resynthesizes — the same engine as tap.shift~ and the +/// tap.pitchaccum~ voices (Hermite-interpolated fractional taps, complementary sin^2 / +/// cos^2 envelope pair summing to 1), with its grain window locked to two detected +/// periods. Period-locking makes the two taps sit exactly one period apart on voiced +/// input, so they sum coherently — the property that carries a delay-line shifter most +/// of the way to pitch-synchronous (PSOLA) quality. On unpitched input the correction +/// relaxes to zero and the tap pair imposes a mild moving comb coloration — the known +/// trade of this engine class. +/// +/// Resynthesis is backend-selectable behind one interface (see `enum backend`): the +/// two-tap grain engine above (the validated low-latency default), true TD-PSOLA +/// (tap::dsp::psola — formant-preserving on voice), and a peak-locked phase vocoder +/// (tap::dsp::pvoc — one-frame latency, strongest on dense material). The detector, +/// mapper, and retune glide are shared; only the last stage swaps. +/// +/// Two target modes: `scale` snaps to a key + 12-bit scale mask (per-note enables, +/// editable individually), `midi` snaps to the nearest currently-held MIDI note and +/// leaves the signal untouched when none are held. An optional auto-key learner +/// (set_autokey) folds every voiced analysis into a slowly-forgetting pitch-class +/// histogram scored against the published Krumhansl-Kessler profiles; it never acts +/// on its own — autokey_apply() adopts the estimate as key + scale when asked. +/// Detection runs every ~5 ms on a +/// worst-case lag range fixed at prepare(); the user frequency range only filters +/// results, so every setter is allocation-free and safe while audio runs. Double +/// precision throughout; C++ stdlib + DspTap only. +/// @author Timothy Place +// SPDX-License-Identifier: BSD-3-Clause +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include "tap/dsp/psola.h" +#include "tap/dsp/pvoc.h" +#include "tap/dsp/yin.h" + +namespace tap::tools { + namespace tune { + + constexpr double k_pi = 3.14159265358979323846; + + // detection geometry (worst-case bounds; the user range filters within them) + constexpr double k_floor_freq_hz = 55.0; // deepest searched lag (A1) + constexpr double k_ceil_freq_hz = 2000.0; // shallowest searched lag + constexpr double k_hop_seconds = 256.0 / 48000.0; // analysis cadence (~5.3 ms) + constexpr double k_default_min_hz = 60.0; + constexpr double k_default_max_hz = 1500.0; + + // correction + constexpr double k_default_speed_ms = 20.0; // retune time constant; 0 = hard snap + constexpr double k_max_correction_st = 12.0; + + // resynthesis + constexpr double k_window_periods = 2.0; // grain window = this many detected periods + constexpr double k_min_window_ms = 5.0; + constexpr double k_max_window_ms = 100.0; + constexpr double k_default_window_ms = 30.0; // used until the first detection lands + constexpr double k_window_slew_ms = 15.0; + constexpr double k_base_delay = 3.0; // samples; Hermite interpolation headroom + + /// Build a 12-bit pitch-class mask from scale degrees (bit 0 = the root). + constexpr unsigned make_mask(std::initializer_list degrees) { + unsigned mask = 0u; + for (const int d : degrees) { + mask |= 1u << (((d % 12) + 12) % 12); + } + return mask; + } + + // scale presets, expressed relative to the key root + constexpr unsigned k_scale_chromatic = 0xFFFu; + constexpr unsigned k_scale_major = make_mask({0, 2, 4, 5, 7, 9, 11}); + constexpr unsigned k_scale_minor = make_mask({0, 2, 3, 5, 7, 8, 10}); + constexpr unsigned k_scale_harmonic_minor = make_mask({0, 2, 3, 5, 7, 8, 11}); + constexpr unsigned k_scale_melodic_minor = make_mask({0, 2, 3, 5, 7, 9, 11}); + constexpr unsigned k_scale_major_pentatonic = make_mask({0, 2, 4, 7, 9}); + constexpr unsigned k_scale_minor_pentatonic = make_mask({0, 3, 5, 7, 10}); + + // auto-key detection + constexpr double k_autokey_memory_s = 60.0; // histogram forgetting time constant + constexpr double k_autokey_min_mass = 100.0; // voiced analyses (~0.5 s) before an estimate is offered + + // Krumhansl-Kessler key profiles (Krumhansl, "Cognitive Foundations of Musical Pitch", + // 1990) — the standard published weights for pitch-class-histogram key finding. + constexpr std::array k_key_profile_major = {6.35, 2.23, 3.48, 2.33, 4.38, 4.09, + 2.52, 5.19, 2.39, 3.66, 2.29, 2.88}; + constexpr std::array k_key_profile_minor = {6.33, 2.68, 3.52, 5.38, 2.60, 3.53, + 2.54, 4.75, 3.98, 2.69, 3.34, 3.17}; + + /// Target-selection mode. + enum class mode : int { + scale = 0, // snap to the key/scale note mask + midi // snap to the nearest held MIDI note; none held = no correction + }; + + /// An auto-key estimate: key is a pitch class (0 = C .. 11 = B), or -1 while there is not + /// yet enough voiced material; confidence is the winning profile correlation, 0..1-ish. + struct key_estimate { + int key; + bool minor; + double confidence; + + bool valid() const { return key >= 0; } + }; + + /// Resynthesis backend. All three sit behind the same detector and mapper; + /// they trade differently: + /// - grain: the two-tap tap.shift~ engine, window locked to an even + /// multiple of the detected period. Waveform-preserving, lowest latency + /// (a few ms), the validated default. + /// - psola: TD-PSOLA (tap::dsp::psola). Formant-preserving on voice-like + /// material (it resamples the spectral envelope — pure tones far from a + /// new harmonic thin out); latency ~2x the deepest detectable period. + /// - pvoc: phase vocoder (tap::dsp::pvoc), peak-locked. Waveform-class + /// quality on dense/polyphonic-ish material; latency of one FFT frame. + enum class backend : int { grain = 0, psola, pvoc }; + + /// The full monophonic corrector: detector -> mapper -> transposer. + class corrector { + public: + // -- lifecycle ------------------------------------------------------------------------------- + + /// Allocate for the sample rate. Call before processing; resets all running state. + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + + const size_t tau_min = std::max(2, static_cast(m_sr / k_ceil_freq_hz)); + const size_t tau_max = static_cast(std::ceil(m_sr / k_floor_freq_hz)); + m_detector.emplace(tau_max, tau_min, tau_max); // window = tau_max, the paper's W + m_detector->set_threshold(m_threshold); + + // alternate resynthesis backends (the grain engine shares the buffers below) + m_psola.emplace(tau_max); // sized to the deepest detectable period + size_t fft = 64; + while (fft < static_cast(std::ceil(1024.0 * m_sr / 48000.0))) { + fft *= 2; // ~21 ms frame at any rate + } + m_pvoc.emplace(fft); + m_pvoc->set_formant(m_formant); + + m_frame.assign(m_detector->frame_size(), 0.0); + m_ring.assign(m_detector->frame_size(), 0.0); + m_ring_write = 0; + + m_hop = std::max(64, static_cast(std::lround(k_hop_seconds * m_sr))); + m_hop_count = 0; + m_autokey_leak = std::exp(-(static_cast(m_hop) / m_sr) / k_autokey_memory_s); + + const size_t n = static_cast(std::ceil(k_max_window_ms * 0.001 * m_sr + k_base_delay)) + 16; + m_buffer.assign(n, 0.0); + m_write = 0; + m_phase = 0.0; + + m_window_samples = m_window_target = k_default_window_ms * 0.001 * m_sr; + m_window_coeff = 1.0 - std::exp(-1.0 / (k_window_slew_ms * 0.001 * m_sr)); + m_period_samples = m_period_target = m_sr / 220.0; // neutral until detection lands + + m_applied_st = 0.0; + m_target_st = 0.0; + m_detected_hz = 0.0; + m_target_midi = -1.0; + } + + bool prepared() const { return m_detector.has_value(); } + + /// Zero the audio state (buffers, glides). Parameters and held notes are untouched. + void clear() { + std::fill(m_ring.begin(), m_ring.end(), 0.0); + std::fill(m_frame.begin(), m_frame.end(), 0.0); + std::fill(m_buffer.begin(), m_buffer.end(), 0.0); + m_ring_write = 0; + m_write = 0; + m_phase = 0.0; + m_hop_count = 0; + m_applied_st = 0.0; + m_target_st = 0.0; + m_detected_hz = 0.0; + m_target_midi = -1.0; + if (prepared()) { + m_window_samples = m_window_target = k_default_window_ms * 0.001 * m_sr; + m_period_samples = m_period_target = m_sr / 220.0; + m_psola->clear(); + m_pvoc->clear(); + } + } + + // -- parameters (allocation-free; safe while audio runs) ------------------------------------- + + /// Key root as a pitch class, 0 = C .. 11 = B. Re-derives the note mask from key + scale, + /// discarding any individual note_enable() edits. + void set_key(int pitch_class) { + m_key = ((pitch_class % 12) + 12) % 12; + rebuild_notes(); + } + + /// 12-bit scale mask relative to the key (bit 0 = root; see the k_scale_* presets). + /// Re-derives the note mask, discarding any individual note_enable() edits. + void set_scale(unsigned mask) { + m_scale = mask & 0xFFFu; + rebuild_notes(); + } + + /// Set the effective note mask directly, as ABSOLUTE pitch classes (bit 0 = C .. bit 11 = B). + void set_notes(unsigned absolute_mask) { m_notes = absolute_mask & 0xFFFu; } + + /// Toggle one absolute pitch class (0 = C .. 11 = B) in the effective note mask. + void note_enable(int pitch_class, bool enabled) { + const unsigned bit = 1u << (((pitch_class % 12) + 12) % 12); + if (enabled) { + m_notes |= bit; + } + else { + m_notes &= ~bit; + } + } + + void set_mode(mode m) { m_mode = m; } + + // -- auto-key detection ---------------------------------------------------------------------- + + /// Enable the key learner: every voiced analysis adds its pitch class to a slowly + /// forgetting histogram (~60 s memory), scored on demand against the published + /// Krumhansl-Kessler major/minor profiles. Learning only — nothing is applied until + /// autokey_apply(). Turning it on from off starts a fresh histogram. + void set_autokey(bool on) { + if (on && !m_autokey) { + autokey_reset(); + } + m_autokey = on; + } + + bool autokey() const { return m_autokey; } + + /// Forget everything learned so far. + void autokey_reset() { m_pc_hist.fill(0.0); } + + /// Best of the 24 keys by Pearson correlation between the histogram and the rotated + /// profile; invalid until ~half a second of voiced material has been heard. + key_estimate autokey_estimate() const { + double mass = 0.0; + for (const double v : m_pc_hist) { + mass += v; + } + if (mass < k_autokey_min_mass) { + return {-1, false, 0.0}; + } + + key_estimate best{-1, false, -2.0}; + for (int minor = 0; minor < 2; ++minor) { + const auto& profile = (minor != 0) ? k_key_profile_minor : k_key_profile_major; + for (int key = 0; key < 12; ++key) { + const double r = correlate(profile, key); + if (r > best.confidence) { + best = {key, minor != 0, r}; + } + } + } + best.confidence = std::clamp(best.confidence, 0.0, 1.0); + return best; + } + + /// Apply the current estimate as key + scale (major or natural minor). Returns whether + /// an estimate was available to apply. + bool autokey_apply() { + const key_estimate e = autokey_estimate(); + if (!e.valid()) { + return false; + } + set_key(e.key); + set_scale(e.minor ? k_scale_minor : k_scale_major); + return true; + } + + /// LPC formant preservation on the pvoc backend (see tap::dsp::basic_pvoc): + /// the correction shifts the excitation while the spectral envelope stays. + /// The psola backend is inherently formant-preserving and the grain engine + /// waveform-preserving, so the flag only changes the pvoc path. + void set_formant(bool on) { + m_formant = on; + if (prepared()) { + m_pvoc->set_formant(on); + } + } + + bool formant() const { return m_formant; } + + /// Select the resynthesis backend. The incoming backend's running state + /// is cleared so it starts from silence — expect a brief fade-in, not a + /// splice of stale audio. Allocation-free (backends exist from prepare()). + void set_backend(backend b) { + if (b == m_backend) { + return; + } + m_backend = b; + if (!prepared()) { + return; + } + if (b == backend::psola) { + m_psola->clear(); + } + else if (b == backend::pvoc) { + m_pvoc->clear(); + } + else { + std::fill(m_buffer.begin(), m_buffer.end(), 0.0); + m_phase = 0.0; + } + } + + /// Retune speed: the exponential time constant (ms) of the glide onto the target. + /// 0 snaps instantly — the hard quantize effect. + void set_speed(double ms) { m_speed_ms = std::max(0.0, ms); } + + /// Correction depth, 0..100%. 100 lands on the target; 50 corrects half the distance. + void set_amount(double pct) { m_amount = std::clamp(pct, 0.0, 100.0) * 0.01; } + + /// Detection range filter, Hz. Estimates outside it are treated as unpitched. + void set_range(double min_hz, double max_hz) { + m_min_hz = std::clamp(min_hz, k_floor_freq_hz, k_ceil_freq_hz); + m_max_hz = std::clamp(max_hz, m_min_hz, k_ceil_freq_hz); + } + + /// YIN voicing threshold (see tap::dsp::basic_yin) — lower is stricter. + void set_threshold(double t) { + m_threshold = std::clamp(t, 0.001, 1.0); + if (prepared()) { + m_detector->set_threshold(m_threshold); + } + } + + // -- MIDI target mode ------------------------------------------------------------------------ + + void note_on(int note) { + if (note >= 0 && note < 128) { + m_held[static_cast(note)] = true; + } + } + + void note_off(int note) { + if (note >= 0 && note < 128) { + m_held[static_cast(note)] = false; + } + } + + void notes_off() { m_held.fill(false); } + + // -- introspection (for meters / outlets / tests) -------------------------------------------- + + int key() const { return m_key; } + unsigned scale() const { return m_scale; } + unsigned notes() const { return m_notes; } + mode target_mode() const { return m_mode; } + backend resynth_backend() const { return m_backend; } + double speed() const { return m_speed_ms; } + double amount() const { return m_amount * 100.0; } + double threshold() const { return m_threshold; } + + /// Last detected fundamental, Hz; 0 while unpitched. + double detected_hz() const { return m_detected_hz; } + + /// Current target note as (fractional) MIDI; -1 while there is no target. + double target_midi() const { return m_target_midi; } + + /// Correction currently applied, semitones (the slewed value the ratio follows). + double applied_semitones() const { return m_applied_st; } + + // -- audio ----------------------------------------------------------------------------------- + + double process(double in) { + if (!prepared()) { + return in; + } + + // feed the detector ring; analyze every hop + m_ring[m_ring_write] = in; + if (++m_ring_write >= m_ring.size()) { + m_ring_write = 0; + } + if (++m_hop_count >= m_hop) { + m_hop_count = 0; + analyze(); + } + + // glide the applied correction onto its target (0 ms = snap) + if (m_speed_ms <= 0.0) { + m_applied_st = m_target_st; + } + else { + const double a = 1.0 - std::exp(-1.0 / (m_speed_ms * 0.001 * m_sr)); + m_applied_st += (m_target_st - m_applied_st) * a; + } + m_window_samples += (m_window_target - m_window_samples) * m_window_coeff; + m_period_samples += (m_period_target - m_period_samples) * m_window_coeff; + + const double ratio = std::exp2(m_applied_st / 12.0); + if (m_backend == backend::psola) { + return m_psola->process(in, m_period_samples, ratio); + } + if (m_backend == backend::pvoc) { + return m_pvoc->process(in, ratio); + } + + // two-tap transposer, window locked to the detected period (tap.shift~ engine) + m_buffer[m_write] = in; + + const double ph_a = m_phase; + double ph_b = ph_a + 0.5; + if (ph_b >= 1.0) { + ph_b -= 1.0; + } + const double ea = envelope(ph_a); + const double eb = 1.0 - ea; // exact complement: sin^2 + cos^2 + + double y = 0.0; + if (ea > 0.0) { + y += ea * read_hermite(k_base_delay + m_window_samples * ph_a); + } + if (eb > 0.0) { + y += eb * read_hermite(k_base_delay + m_window_samples * ph_b); + } + + m_phase += -(ratio - 1.0) / m_window_samples; + m_phase -= std::floor(m_phase); + + if (++m_write >= m_buffer.size()) { + m_write = 0; + } + return y; + } + + private: + void rebuild_notes() { + unsigned absolute = 0u; + for (int d = 0; d < 12; ++d) { + if ((m_scale >> d) & 1u) { + absolute |= 1u << ((d + m_key) % 12); + } + } + m_notes = absolute; + } + + /// One detection pass over the last frame_size() input samples, then retarget. + void analyze() { + const size_t n = m_ring.size(); + for (size_t i = 0; i < n; ++i) { + m_frame[i] = m_ring[(m_ring_write + i) % n]; // oldest first + } + const auto r = m_detector->analyze(m_frame.data()); + + double hz = 0.0; + if (r.voiced()) { + const double f = m_sr / r.period; + if (f >= m_min_hz && f <= m_max_hz) { + hz = f; + } + } + m_detected_hz = hz; + + if (m_autokey) { + for (double& v : m_pc_hist) { + v *= m_autokey_leak; + } + if (hz > 0.0) { + const long note = std::lround(69.0 + 12.0 * std::log2(hz / 440.0)); + m_pc_hist[static_cast(((note % 12) + 12) % 12)] += 1.0; + } + } + + if (hz <= 0.0) { + m_target_st = 0.0; // unpitched: relax toward no correction, hold the window + m_target_midi = -1.0; + return; + } + + const double detected = 69.0 + 12.0 * std::log2(hz / 440.0); + const double target = select_target(detected); + m_target_midi = target; + if (target < 0.0) { + m_target_st = 0.0; + } + else { + m_target_st = std::clamp(target - detected, -k_max_correction_st, k_max_correction_st) * m_amount; + } + + // Window = an EVEN multiple of the period, so the two taps (window/2 apart) always sit + // an integer number of periods apart — the coherence that makes the average ratio exact. + // Clamping to a fixed ms instead measurably biases the pitch (~5 cents at 452 Hz). + const double period_samples = m_sr / hz; + m_period_target = period_samples; // for the psola backend + const double two_periods = k_window_periods * period_samples; + const double min_w = k_min_window_ms * 0.001 * m_sr; + const double max_w = k_max_window_ms * 0.001 * m_sr; + const double multiple = std::max(1.0, std::ceil(min_w / two_periods)); + m_window_target = std::min(multiple * two_periods, max_w); + } + + /// Nearest allowed note (as MIDI) for a detected MIDI pitch, or -1 when nothing is allowed. + double select_target(double detected) const { + if (m_mode == mode::midi) { + double best = -1.0; + double best_dist = 1.0e9; + for (int n = 0; n < 128; ++n) { + if (m_held[static_cast(n)]) { + const double dist = std::abs(detected - static_cast(n)); + if (dist < best_dist) { + best_dist = dist; + best = static_cast(n); + } + } + } + return best; + } + + if (m_notes == 0u) { + return -1.0; + } + const int center = static_cast(std::lround(detected)); + double best = -1.0; + double best_dist = 1.0e9; + for (int off = -6; off <= 6; ++off) { // any non-empty mask has a note within a tritone + const int n = center + off; + const unsigned pc = static_cast(((n % 12) + 12) % 12); + if ((m_notes >> pc) & 1u) { + const double dist = std::abs(detected - static_cast(n)); + if (dist < best_dist) { + best_dist = dist; + best = static_cast(n); + } + } + } + return best; + } + + /// Pearson correlation between the pitch-class histogram and a key profile rotated to + /// the candidate key: profile degree d scores histogram bin (key + d) mod 12. + double correlate(const std::array& profile, int key) const { + double hm = 0.0; + double pm = 0.0; + for (int d = 0; d < 12; ++d) { + hm += m_pc_hist[static_cast(d)]; + pm += profile[static_cast(d)]; + } + hm /= 12.0; + pm /= 12.0; + + double num = 0.0; + double hd = 0.0; + double pd = 0.0; + for (int d = 0; d < 12; ++d) { + const double h = m_pc_hist[static_cast((key + d) % 12)] - hm; + const double p = profile[static_cast(d)] - pm; + num += h * p; + hd += h * h; + pd += p * p; + } + const double denom = std::sqrt(hd * pd); + return (denom > 0.0) ? num / denom : 0.0; + } + + /// Grain envelope: sin^2 rise/fall over the half cycle — the two taps' envelopes sum to 1. + static double envelope(double ph) { + const double s = std::sin(k_pi * ph); + return s * s; + } + + size_t wrap(long i) const { + const long n = static_cast(m_buffer.size()); + return static_cast(((i % n) + n) % n); + } + + double read_hermite(double d) const { + const double pos = static_cast(m_write) - d; + const double fpos = std::floor(pos); + const double frac = pos - fpos; + const long base = static_cast(fpos); + const double xm1 = m_buffer[wrap(base - 1)]; + const double x0 = m_buffer[wrap(base)]; + const double x1 = m_buffer[wrap(base + 1)]; + const double x2 = m_buffer[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); + } + + // configuration + double m_sr{48000.0}; + int m_key{0}; + unsigned m_scale{k_scale_chromatic}; + unsigned m_notes{k_scale_chromatic}; + mode m_mode{mode::scale}; + double m_speed_ms{k_default_speed_ms}; + double m_amount{1.0}; + double m_min_hz{k_default_min_hz}; + double m_max_hz{k_default_max_hz}; + double m_threshold{tap::dsp::yin::k_default_threshold}; + + // detection + std::optional m_detector; + std::optional m_psola; + std::optional m_pvoc; + backend m_backend{backend::grain}; + bool m_formant{false}; + bool m_autokey{false}; + double m_autokey_leak{1.0}; + std::array m_pc_hist{}; + std::vector m_ring; + std::vector m_frame; + size_t m_ring_write{0}; + int m_hop{256}; + int m_hop_count{0}; + std::array m_held{}; + + // correction state + double m_detected_hz{0.0}; + double m_target_midi{-1.0}; + double m_target_st{0.0}; + double m_applied_st{0.0}; + + // resynthesis + std::vector m_buffer; + size_t m_write{0}; + double m_phase{0.0}; + double m_window_samples{0.0}; + double m_window_target{0.0}; + double m_window_coeff{0.0}; + double m_period_samples{218.0}; + double m_period_target{218.0}; + }; + + } // namespace tune +} // namespace tap::tools diff --git a/notebooks/taptools_py.py b/notebooks/taptools_py.py index 2304d45..d976094 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -13,8 +13,10 @@ (`Convolver`), tap.svf~ (`Svf`), tap.ladder~ (`Ladder`), tap.diode~ (`Diode`), tap.303~ (`TB303`), tap.vco~ (`Vco`), tap.autowah~ (`Wah`), the step-sequencer rows behind tap.808.seq~ / tap.303.seq~ (`TriggerRow`, -`NoteRow`), and tap.808.kick~ (`Kick`). Parameter names on the kernel -classes mirror each kernel header's param_index enum. +`NoteRow`), tap.808.kick~ (`Kick`), 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. New BSD License. """ @@ -180,6 +182,37 @@ def load() -> ctypes.CDLL: "taptools_kick_trigger": ([vp, ctypes.c_double], ctypes.c_int), "taptools_kick_reset": ([vp], ctypes.c_int), "taptools_kick_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_tune_create": ([], vp), + "taptools_tune_destroy": ([vp], None), + "taptools_tune_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tune_clear": ([vp], ctypes.c_int), + "taptools_tune_set_key": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_tune_set_scale": ([vp, ctypes.c_uint], ctypes.c_int), + "taptools_tune_set_notes": ([vp, ctypes.c_uint], ctypes.c_int), + "taptools_tune_set_mode": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_tune_set_backend": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_tune_set_speed": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tune_set_amount": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tune_set_range": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_tune_set_threshold": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tune_set_formant": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_tune_set_autokey": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_tune_autokey_reset": ([vp], ctypes.c_int), + "taptools_tune_autokey_estimate": ([vp, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int), + ctypes.POINTER(ctypes.c_double)], ctypes.c_int), + "taptools_tune_autokey_apply": ([vp], ctypes.c_int), + "taptools_tune_note_on": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_tune_note_off": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_tune_notes_off": ([vp], ctypes.c_int), + "taptools_tune_detected_hz": ([vp], ctypes.c_double), + "taptools_tune_target_midi": ([vp], ctypes.c_double), + "taptools_tune_applied_semitones": ([vp], ctypes.c_double), + "taptools_tune_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), + "taptools_yin_track": ([vp, f64p, ctypes.c_int, ctypes.c_int, f64p, ctypes.c_int], + ctypes.c_int), } for name, (argtypes, restype) in sigs.items(): fn = getattr(lib, name) @@ -667,3 +700,115 @@ def __del__(self): if h: _LIB.taptools_kick_destroy(h) self._h = None + + +# scale masks and enums mirroring taptools/tune.h +TUNE_SCALES = { + "chromatic": 0xFFF, + "major": sum(1 << d for d in (0, 2, 4, 5, 7, 9, 11)), + "minor": sum(1 << d for d in (0, 2, 3, 5, 7, 8, 10)), +} +TUNE_MODES = {"scale": 0, "midi": 1} +TUNE_BACKENDS = {"grain": 0, "psola": 1, "pvoc": 2} + + +class Tune: + """tap.tune~'s corrector (tap::tools::tune::corrector) — the full chain: + YIN detection, scale/MIDI target mapping, retune glide, and the selectable + resynthesis backend (grain / psola / pvoc).""" + + def __init__(self, sr: float = 48000.0, **params): + self._h = _LIB.taptools_tune_create() + _check(_LIB.taptools_tune_prepare(self._h, float(sr)), "prepare") + self.set(**params) + + def set(self, *, key=None, scale=None, notes=None, mode=None, backend=None, speed=None, + amount=None, threshold=None, formant=None) -> "Tune": + if key is not None: + _check(_LIB.taptools_tune_set_key(self._h, int(key)), "key") + if scale is not None: + mask = TUNE_SCALES[scale] if isinstance(scale, str) else int(scale) + _check(_LIB.taptools_tune_set_scale(self._h, mask), "scale") + if notes is not None: + _check(_LIB.taptools_tune_set_notes(self._h, int(notes)), "notes") + if mode is not None: + _check(_LIB.taptools_tune_set_mode(self._h, TUNE_MODES[mode]), "mode") + if backend is not None: + _check(_LIB.taptools_tune_set_backend(self._h, TUNE_BACKENDS[backend]), "backend") + if speed is not None: + _check(_LIB.taptools_tune_set_speed(self._h, float(speed)), "speed") + if amount is not None: + _check(_LIB.taptools_tune_set_amount(self._h, float(amount)), "amount") + if threshold is not None: + _check(_LIB.taptools_tune_set_threshold(self._h, float(threshold)), "threshold") + if formant is not None: + _check(_LIB.taptools_tune_set_formant(self._h, int(bool(formant))), "formant") + return self + + def set_autokey(self, on: bool) -> None: + _check(_LIB.taptools_tune_set_autokey(self._h, int(bool(on))), "autokey") + + def autokey_estimate(self) -> tuple[int, bool, float]: + """(key 0-11 or -1, minor, confidence) from the Krumhansl-Kessler scorer.""" + key = ctypes.c_int() + minor = ctypes.c_int() + conf = ctypes.c_double() + _check(_LIB.taptools_tune_autokey_estimate(self._h, ctypes.byref(key), ctypes.byref(minor), + ctypes.byref(conf)), "autokey_estimate") + return key.value, bool(minor.value), conf.value + + def autokey_apply(self) -> bool: + return _LIB.taptools_tune_autokey_apply(self._h) == 1 + + def note_on(self, note: int) -> None: + _check(_LIB.taptools_tune_note_on(self._h, int(note)), "note_on") + + def note_off(self, note: int) -> None: + _check(_LIB.taptools_tune_note_off(self._h, int(note)), "note_off") + + @property + def detected_hz(self) -> float: + return _LIB.taptools_tune_detected_hz(self._h) + + @property + def applied_semitones(self) -> float: + return _LIB.taptools_tune_applied_semitones(self._h) + + def process(self, x) -> np.ndarray: + x = _f64(x) + out = np.empty_like(x) + _check(_LIB.taptools_tune_process(self._h, _p64(x), _p64(out), x.size), "process") + return out + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_tune_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.""" + + def __init__(self, window: int = 873, tau_min: int = 24, tau_max: int = 873): + self._h = _LIB.taptools_yin_create(window, tau_min, tau_max) + if not self._h: + raise ValueError("bad yin geometry") + + @property + def frame_size(self) -> int: + return _LIB.taptools_yin_frame_size(self._h) + + def track(self, x, hop: int = 256) -> np.ndarray: + """Fractional periods in samples (0 = unvoiced) every `hop` samples.""" + x = _f64(x) + out = np.zeros(x.size // hop + 1) + n = _LIB.taptools_yin_track(self._h, _p64(x), x.size, hop, _p64(out), out.size) + return out[:max(n, 0)] + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_yin_destroy(h) + self._h = None diff --git a/notebooks/tune.ipynb b/notebooks/tune.ipynb new file mode 100644 index 0000000..6442893 --- /dev/null +++ b/notebooks/tune.ipynb @@ -0,0 +1,356 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1beead44", + "metadata": {}, + "source": [ + "# tap.tune~ — the pitch corrector, measured\n", + "\n", + "The full correction chain behind `tap.tune~` — YIN detection, scale/MIDI target mapping, the\n", + "retune-speed glide, and the three selectable resynthesis backends — driven as the **actual\n", + "shipping kernel** (`taptools/tune.h`) through the C ABI (`Tune` in `taptools_py`). Pitch tracks\n", + "are measured with the same shared DspTap detector the corrector itself uses (`Yin`).\n", + "\n", + "Contents:\n", + "\n", + "1. **Retune speed** — the primary musical control, from hard snap to transparent.\n", + "2. **The three backends compared** — `grain` / `psola` / `pvoc` on the same vibrato \"voice\":\n", + " what each one is for, and what it costs in latency.\n", + "3. **Formant preservation** — the LPC option on the `pvoc` backend, holding a synthetic\n", + " formant in place through a large MIDI-mode correction.\n", + "\n", + "Deeper primitive-level material (why PSOLA thins pure tones, why the phase vocoder needs peak\n", + "locking) lives in the DspTap notebook `notebooks/pitchshift.ipynb` in the `tap/dsptap` repo." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "781d10bb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T13:14:01.420692Z", + "iopub.status.busy": "2026-07-22T13:14:01.420459Z", + "iopub.status.idle": "2026-07-22T13:14:02.650343Z", + "shell.execute_reply": "2026-07-22T13:14:02.648921Z" + } + }, + "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", + "\n", + "sr = 48000.0\n", + "HOP = 256\n", + "\n", + "def saw(freq_or_track, seconds=None, harmonics=12):\n", + " \"\"\"Band-limited saw; freq may be a scalar or a per-sample frequency track.\"\"\"\n", + " if np.isscalar(freq_or_track):\n", + " f = np.full(int(seconds * sr), float(freq_or_track))\n", + " else:\n", + " f = np.asarray(freq_or_track)\n", + " phase = np.cumsum(f) / sr\n", + " x = sum(np.sin(2 * np.pi * h * phase) / h for h in range(1, harmonics + 1))\n", + " return x / np.abs(x).max()\n", + "\n", + "def track_hz(x):\n", + " \"\"\"Pitch track (Hz, NaN where unvoiced) via the shared DspTap detector.\"\"\"\n", + " periods = tap.Yin().track(x, hop=HOP)\n", + " hz = np.where(periods > 0, sr / np.maximum(periods, 1e-9), np.nan)\n", + " t = (np.arange(len(hz)) * HOP + tap.Yin().frame_size) / sr\n", + " return t, hz\n", + "\n", + "def cents(f, ref):\n", + " return 1200 * np.log2(f / ref)" + ] + }, + { + "cell_type": "markdown", + "id": "0fa0529a", + "metadata": {}, + "source": [ + "## 1 · Retune speed: hard snap to transparent\n", + "\n", + "A sawtooth held 46 cents sharp of A3 (226 Hz vs 220). The `speed` parameter is the exponential\n", + "time constant of the glide onto the target: 0 ms snaps instantly (the hard-quantize vocal\n", + "effect), 20 ms is classic tight correction, 200 ms corrects so slowly it reads as drift. This is\n", + "the one knob that takes the same machinery from transparent intonation repair to the signature\n", + "effect." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "beb4f638", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T13:14:02.653293Z", + "iopub.status.busy": "2026-07-22T13:14:02.652898Z", + "iopub.status.idle": "2026-07-22T13:14:06.541787Z", + "shell.execute_reply": "2026-07-22T13:14:06.540302Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = saw(226.0, seconds=1.2)\n", + "\n", + "fig, ax = plt.subplots()\n", + "t_in, hz_in = track_hz(x)\n", + "ax.plot(t_in, cents(hz_in, 220.0), color=\"gray\", lw=1.2, label=\"input (+46 c)\")\n", + "for speed, color in [(0.0, C[0]), (20.0, C[1]), (200.0, C[2])]:\n", + " c = tap.Tune(sr, speed=speed) # defaults: chromatic, grain backend\n", + " t, hz = track_hz(c.process(x))\n", + " ax.plot(t, cents(hz, 220.0), color=color, label=f\"speed {speed:g} ms\")\n", + "ax.axhline(0, color=\"k\", lw=0.8)\n", + "ax.set(xlabel=\"time (s)\", ylabel=\"cents from A3 (220 Hz)\", ylim=(-15, 60),\n", + " title=\"retune speed: the glide onto the target\")\n", + "ax.legend(loc=\"upper right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "372f8fa0", + "metadata": {}, + "source": [ + "## 2 · The three backends on the same \"voice\"\n", + "\n", + "The detector, mapper, and glide are shared; only the resynthesis swaps (`set_backend`). The test\n", + "signal is a sawtooth \"voice\" wobbling ±40 cents around 226 Hz at 5 Hz — enough drift that hard\n", + "snapping quantizes it audibly. All three land the correction; they differ in *how* and in what\n", + "they cost:\n", + "\n", + "| backend | method | character | latency @ 48 kHz |\n", + "|---|---|---|---|\n", + "| `grain` | two-tap delay-line, window period-locked | waveform-preserving, cheapest | a few ms |\n", + "| `psola` | TD-PSOLA (`tap::dsp::psola`) | formant-preserving on voice | ~36 ms (2× deepest period) |\n", + "| `pvoc` | peak-locked phase vocoder (`tap::dsp::pvoc`) | strongest on dense material | ~21 ms (one FFT frame) |" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c47386d0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T13:14:06.544293Z", + "iopub.status.busy": "2026-07-22T13:14:06.544024Z", + "iopub.status.idle": "2026-07-22T13:14:12.745535Z", + "shell.execute_reply": "2026-07-22T13:14:12.743935Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grain : settled output 220.00 Hz (target 220.00), tail peak 1.00\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "psola : settled output 220.00 Hz (target 220.00), tail peak 0.95\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pvoc : settled output 220.00 Hz (target 220.00), tail peak 0.97\n" + ] + } + ], + "source": [ + "t_samp = np.arange(int(1.5 * sr))\n", + "vibrato = 226.0 * 2 ** (0.40 / 12 * np.sin(2 * np.pi * 5.0 * t_samp / sr)) # ±40 cents\n", + "x = saw(vibrato)\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 3.6))\n", + "t_in, hz_in = track_hz(x)\n", + "ax.plot(t_in, cents(hz_in, 220.0), color=\"gray\", lw=1.0, alpha=0.8, label=\"input (vibrato ±40 c)\")\n", + "for backend, color in [(\"grain\", C[0]), (\"psola\", C[1]), (\"pvoc\", C[2])]:\n", + " c = tap.Tune(sr, speed=10.0, backend=backend)\n", + " t, hz = track_hz(c.process(x))\n", + " ax.plot(t, cents(hz, 220.0), color=color, lw=1.2, label=backend)\n", + "ax.axhline(0, color=\"k\", lw=0.8)\n", + "ax.set(xlabel=\"time (s)\", ylabel=\"cents from A3\", ylim=(-60, 60),\n", + " title=\"hard-ish snap (speed 10 ms) through each backend\")\n", + "ax.legend(loc=\"upper right\", ncols=4, fontsize=8)\n", + "plt.show()\n", + "\n", + "for backend in (\"grain\", \"psola\", \"pvoc\"):\n", + " c = tap.Tune(sr, speed=0.0, backend=backend)\n", + " y = c.process(saw(226.0, seconds=1.0))\n", + " tail = y[-int(0.3 * sr):]\n", + " p = tap.Yin().track(tail, hop=HOP)\n", + " p = p[p > 0]\n", + " print(f\"{backend:6s}: settled output {sr / np.median(p):7.2f} Hz \"\n", + " f\"(target 220.00), tail peak {np.abs(tail).max():.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "790b192d", + "metadata": {}, + "source": [ + "All three tracks sit on the same corrected line — the differences are in the resynthesis\n", + "character (and latency), not the intonation. Note the small onset offsets between the tracks:\n", + "that is each backend's latency made visible (grain ≈ ms, pvoc = 1024 samples, psola ≈ 1750\n", + "samples at 48 kHz).\n", + "\n", + "## 3 · Formant preservation on the `pvoc` backend\n", + "\n", + "Corrections of a few cents don't move formants audibly, but MIDI mode can command *large*\n", + "shifts — the chipmunk regime. `set_formant(true)` enables the LPC source-filter option on the\n", + "phase-vocoder backend (see `tap/dsp/pvoc.h`): the excitation shifts, the envelope stays. The\n", + "`psola` backend needs no flag (envelope preservation is its resampling rule); the `grain` engine\n", + "is waveform-preserving, the right default for small corrections.\n", + "\n", + "Test: a 240 Hz \"voice\" with a synthetic formant bump at 960 Hz, corrected in MIDI mode to a held\n", + "E4 (329.6 Hz — a 5.5-semitone jump)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e20091b2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T13:14:12.747909Z", + "iopub.status.busy": "2026-07-22T13:14:12.747631Z", + "iopub.status.idle": "2026-07-22T13:14:14.410830Z", + "shell.execute_reply": "2026-07-22T13:14:14.409406Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAugAAAFaCAYAAABMsKhzAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAOxAAADsQBlSsOGwAA+nxJREFUeJzsnXecE1XXx38zk2RLdoFlK73XpXeQ3lGkiAICyqOggIogolh4UFBEpLxKEVBEHwvNAogICAJKbwrSOyttFxa2lyQzc98/pmRSdje7m2ST7P1+PrpkMpnce+dm5sy5v3MOQwghoFAoFAqFQqFQKD4BW9INoFAoFAqFQqFQKFaogU6hUCgUCoVCofgQ1ECnUCgUCoVCoVB8CGqgUygUCoVCoVAoPgQ10CkUCoVCoVAoFB+CGugUCoVCoVAoFIoPQQ10CoVCoVAoFArFh9CVdAMohYPneeTm5jps5zgOISEhHvusL2EymSAIAkJDQ0u6KS5jNpthNpvzHGtRFJGdnQ0AMBqNYBjG5nNhYWEOxwIAhmEQGhqq7p/fd2uP4atkZ2eD4zgEBQWVdFP8AmXehIaGgmX9y9/iatsFQUBOTo5P99FiscBsNsNoNLr1uIE0RlqUe5G/tJfiW5SW+wT9ZfgZ3377LcLDwxEXF2fzX48ePTz6WV9i0qRJaNGihfraZDIhJyenBFtUMDNmzEB4eDiioqKQlZXl8P7y5csRHh6O8PBwXLlyxeFzmZmZDtvi4uIQGxuLoKAgVKhQAQMGDMCPP/6Y53drj+GrtGjRApMmTSrpZvgcgiAgMzMToijabD9y5AjCw8Nx5MiREmpZ0bFve1593LFjB8LDw3H27NmSaKZLLFiwAJGRkW4/rq+PUV7tyYt9+/ahcePGCAsLQ1xcHE6ePOnhFpYMZrPZ6XWeUjiys7NVZ5SW0nKfoAa6n3Lz5k1kZmaq/x04cMArn/UFgoODbTxV48aNQ+vWrUuwRa7Dsiw2btzosH316tUIDw8v1LESExORmZkJk8mEAwcOoH379hg1ahQGDx4Mnufd1GKKL7B3716Eh4fjr7/+stnOcRyMRiM4jiuhlhUd+7bn1cfSjK+PUWHbM2HCBMTHxyMrKwuZmZlo3ry5h1tYMsyYMQPVqlUr6Wb4PQ0bNsSUKVMcthuNRgQHB5dAi7wLNdBLALPZrBrHJpOppJtTJARByPd9URTzNBLtPd55HSuvz8+dOxd79+4FAOTm5oLneYiiqI6pM2+6xWIBIcSl9rhi3ObXv/wYNGgQvvvuO5tt169fx4EDBzBo0KBCHw+QZC41atTAm2++iQ0bNmDjxo348MMPi3Ss4p4bLfmNeWGPBRR9zAGAEFLgnC3MHLFYLLBYLACArKwsGy9Pbm6uU4+iM0+QM+z7qMgXACAnJ0ed54QQtGzZEomJiWjZsqXDcQgheY6XveeTEOKyF9QZmZmZDt/l7PqWk5Ojyuy0bc+vj8765WpbCSHqsfLzaBZlPAo7F31tjPKbHzzPO11xs1gs6jgWpj3K8S5evIjGjRsjJyfH6XW6sHNWOYbZbFYlgsq+efUrv/7mdf9QsP8eZ8czm83qtUE5pvYzRTlmXvs5u6a4ct0t6FpY0HHsPdvKNS87OztPm0b7nna+5NXfrKwsEEJgsVjUfZXv3Lt3L+bOnev0c/ldZ+3b7fOOLELxOrNnzyZGo5EYjUZiMBhITEwMGT16NLlz506Bn/3yyy8JAJKSkkJyc3ML9b3F+SwhhPz999+kW7duJCQkhISGhpLmzZuTH374wWaf3377jbRr145wHEd0Oh1p164dOXTokM0+w4YNIy1btiSnTp0iLVu2JDqdjtSvX58cPXqUEELIp59+SipUqEAYhiE9evQg9+7ds/n8uHHjSL169QghhIwaNYrodDrCsqw6pt26dVP3/eqrr0jdunUJx3EkKCiIPProo+Ty5ctO23P+/HnStm1botPpSHR0NPn8888dxsCV/jlj2rRpBADZunUr0el05O7du+p7s2fPJjVq1CDLli0jAMilS5ccPpeRkZHvNi0dO3YkMTExLu/vbCyKem4IcW3MCSFk/vz5JDo6muh0OtKmTRty9uxZUq9ePTJu3Dib/Yo65spnH3roIaLT6YjRaCQ9e/YkJ0+eLHR7tePStm1bYjQayYIFCwghhJQtW5a8/fbb5LvvviPVqlUjYWFh5J9//iGEEJKYmEiefvppUrZsWcKyLKlQoQKZO3euQzsTExPJM888Q8qXL084jiO1a9cmn332GRFFkWzdupUEBwcTACQkJESd5xcuXCAHDx4kAMjBgwfVY507d47069ePGAwGwnEcadCgAVmzZo3N923dupUAIH///Td56aWXiNFoJHq9ngwbNoxkZma6NLYKoiiSqKgoMn36dHXbqVOnCADSqlUrm30rVapEpk6dSgghNm3Pr4/FaWtCQoJ6rNDQUBIaGkratm1LduzYUeTxOHbsGGnVqhVhGIbExsaS5cuXkzlz5pCgoCC/GCNX5of2XqHlvffeI0ajUR2zvNpjz9q1a4nRaCQAiMFgIEajkbRu3bpQbVL6ePz4cTJhwgRStmxZ0qJFC0IIIZMmTSKVKlUi169fJ506dSI6nY5Uq1aN7Ny5U/3+atWqEYZhSNu2bcn169dtjr1y5Uq1/UFBQSQyMpIMGTKEXL161WY/5Xtu3rxJunfvTvR6PSlXrhz58MMP1X2mTJlC9Ho9AaAes2HDhg5jYn/MK1eukA4dOhCdTkciIyPJ7Nmzne53/fp10q1bNxIWFkZef/119f1FixaR2rVrq9exIUOGkNu3b9scY/369SQ+Pp4YDAZSrlw50qdPH/L333/b7OPKcWJjY8mrr75Kvv/+e1KjRg0SFhZGjhw5Qh577DHSoEEDhz7evn2bsCxL/u///o8QQkjfvn1tbKBq1aqRmTNnEpPJpH5GOV96vV7dd8aMGYQQ4nCfMJlMZNq0aSQmJoawLEsiIiLIiy++SLKyspy2e9OmTaR69eqEZVnSsGFDm+unL0EN9BJGFEVy7tw58tBDD5EuXboUuL9y4TQajepE/M9//kOSkpI8+llBEEjFihXJ6NGjSUpKCuF5npw8eZI8+eST6j6bN28mLMuSt956i6SkpJD09HTy2muvEaPRSC5evKjuN2zYMFK/fn3y5JNPkuvXr5OsrCwybNgwUrVqVbJ69WryzjvvkIyMDHLx4kVSsWJFB4NNa6ATQsjo0aNJfHy8Q5s///xzwjAM+b//+z+SlZVFrl69Sjp06EAqVqxIkpOTbdrToEEDMnToUHLx4kWSm5tLpk+fTliWtWm3q/1zhmIkWywWEhMTQxYvXqy+Fx8fT9566y23GejTp0+3OU5hDfTinBtXx3zVqlVEp9ORlStXktzcXHL27FkyYMAAUr16dZtjFmfMN2zYQFiWJa+88gpJTEwkubm5ZOfOneTtt98udHuVcRk0aJCDAVK2bFnSo0cP8sILL5D79++r29PS0kjt2rVJmzZtyOnTpwnP8+S3334j5cqVIx988IG6X0pKCqlZsyZp1qwZOXbsGOF5nly5coU8//zz6vF2795NAKgPSgr2BvqdO3dIVFQU6dGjB7lx4wbJzMwk77//PgFAVq9erX5OMXYef/xxsn79emIymciBAwdImTJlbIxIV3n88cdJhw4d1NeffPKJep1RjLwLFy4QAGTLli1O255XH93Z1rS0NPLuu++SoKAgcu7cuUJ/x/3790lERAQZNGgQSUpKIqmpqeSVV14hPXr0yNdA95UxcnV+uGKg59eevOA4jsybN89mW2Hn7IABA9Q+KkyaNInExcWRkSNHkrNnz5KcnBzy0ksvkbJly5Kff/6ZTJw4kaSkpJCbN2+S+vXrk4EDB+bbzmvXrpGHH36YxMfHE7PZ7PA9I0aMICdOnCBms5l88sknBADZt2+fut+0adNIZGSkS2OiHHPQoEHkxIkTxGQykW+++Ybo9Xry6aefOuw3ZMgQcuLECSKKovre66+/ToxGI1m9ejXJyckht27dIj169CCNGjVSx+nUqVOE4ziydOlSYjabSXZ2NtmxYwd57bXXCnUcQiRDt1u3bmTs2LE2TpoNGzYQAOTYsWM2fZw3bx7R6XQkMTHRof8Wi4Xs3r2bxMTEqAa4QrVq1ciLL77o8Bl7A33kyJEkIiKCbNu2jZjNZvLnn3+SuLg40qdPH5vPxcbGkl69epFx48aR+/fvkwcPHpDevXuT6tWrE4vF4vwElSDUQC9hLBYLycjIIL/++isBQG7evJnv/hs3biTLli0jSUlJxGQyke3bt5MqVaqQOnXqFGiAFeez165dIwDI9u3b89ynbt26pHfv3jbbRFEkDRo0sPkxDRs2jDAMY2NgnT59mgAgHTt2tPn89OnTSVhYmM02Vwx0URRJxYoVyYABA2y2X7lyhXAcR2bNmuXQnrNnz6rbTCYTKVu2LHn33XcL3T9nKEYyIYS89NJLpH379oQQQk6cOEEAkDNnzrjNQF+yZInNDaOwBnpRz01hxrxatWpk1KhRNvvt37+fALAZy+KMec2aNUmPHj3yfL+wcwSAg/edEMlAr1KlCuF53mb77NmziV6vJwkJCTbb58yZQ8qUKaOuYs2cOZPo9Xpy5cqVPNvqqoH+xhtvkKCgIIfVuK5du5KaNWuqrxVj54033rDZb/z48aR69ep5tiMvli5dSvR6veqtHTRokOrl3LRpEyGEkOXLlxOdTkfS09Odtr0g49Mdbc3MzCQZGRmkSpUq5P333y/0d8yYMYMYjUaSmpqqbhNFkdSrV69AA90XxsjV+eFNA72wc/aVV15xOO6kSZMcjOR79+4RAKR+/fo2v80lS5YQlmVJWlqa0zbyPE8yMjLIsWPHHIxN5Xv27Nlj85kaNWqQ8ePHq68La6A7u7c+99xzJC4uTm17Xvv9+++/hOM4m4d+Qgi5ceMG4ThOXYn48ssvCcMwea6eu3ocQiRDNzY21sZoJ4QQs9lMIiMjyeTJk222N23alDz88MNOvzc3N5dkZGSQN998k9SuXdvmPVcM9PPnzxMAZOHChTb7fPXVVwQA+fPPP23aXaVKFZuHrkOHDjk9p74A1aCXAA8ePMDEiRNRqVIlhIaGIi4uDkOGDAEAXLt2Ld/PDhw4EOPHj0dMTAwMBgN69+6Nr776CpcuXcKXX35Z7M8qOj977VzFihURGxuLKVOmYM2aNbh//77NsRMSEnDx4kX07t3b5vNZWVlo3bq1QyBq5cqVUadOHfV17dq1AQDt27e32a927drIzMx0+L6CuHr1Km7fvo2HH37YZnvNmjVRv359VcOuUKlSJTRo0EB9bTAYUL16dSQkJBSpf/kxYsQIHDx4EFevXsV3332Hpk2bomHDhoXqX34QWTeYV/qyvM6xQlHPjatjnpSUhISEBPTq1ctmvw4dOtikgizOmF+7dg1Xr17F4MGD89ynsHMkNjYWTZo0cXqs7t27OwRq7tixA/Hx8ShfvrxN+1u0aIH09HScOXMGAPD777+jadOmqFmzZp5tdZV9+/ahefPmiIuLs9n+yCOPqP3V0rNnT5vX9erVw82bN13SqGrp3r07LBYL9u7dC1EU8ccff6BXr17o3Lkzdu3aBQDYtWsXWrVqVehg6OK29auvvkLTpk0RGhqKqKgoxMXF4datW06vtQV9x5EjR9CmTRuULVtW3YdhGIfPOcMXxqiw88MbFLZNvXv3dnqcoKAgdOjQQX0dFRWFcuXKoXXr1ja/zdq1a0MURdy4cUPdlpWVhTfffBPVqlVDSEgIYmNj0blzZwCO92SDwYBOnTrZbKtbt656rygKHMc5ZFPr3bs3EhMTbY7rbL9du3ZBEAT06NHD5jpTrlw5VK1aVb1ONmvWDADw+OOPY8eOHQ5ae1ePo9C1a1cYDAabbXq9HsOGDcOaNWvUOXfq1CmcPHkSTz31lLrf6dOnMWjQIERGRqoZyRYsWFCg/eOMffv2AYDDdfyRRx4BAIfreJcuXaDX69XX9erVA4BinT9PQQ30EmDUqFH47bff8PPPP6vBEsoFuihBC127dkVwcDCOHTtW7M9u3rzZJgWjEmVvMBiwc+dO1KhRA8888wyio6PRpk0bbNiwAQCQnJwMAJg+fbpDGscff/zRIXAjJibG5nVQUBA4jnPYrmRrycjIKFS/UlNTAUgXaXuio6ORkpKSb3sAICwsDOnp6QAK37/8aN++PWrWrInvvvsOa9aswciRI13+rCvcvHkTgPRQ5Yy8zrFCUc+Nq2OemJiY537abcUZ8wcPHgCQjOq8KOwcsTcgCnovOTkZp0+fdmj7Y489BqPRqI7bgwcP8m1nYUhNTc2zPwAKnPdhYWHgeb7QaUvr16+PChUqYPfu3Thx4gTS0tLQpUsXdOvWDbt37wYA7NmzB926dSvUcYvb1vXr12PMmDF46aWXcPfuXfV6W6dOHafX2oK+IzExMd/xzQ9fGCNX50dedRWKE0icF4Wds3n9DqOiohzabTQaXbqnTJw4Ef/73//w3XffITs7G1lZWeoDtP08iYqKcnB+aO8VRSEiIsLhAV/pv3K9VL7bfj/lOtm9e3eHa40y5wHJQP/xxx9x9+5d9OnTB+XLl0f//v3xzz//FOo4Cnmdh6eeegpJSUn47bffAADffPMNypQpg4EDBwKQznfv3r3BMAz++usvNWnGzJkzC+0YUI6njI2WyMhIsCzr0jUPQLHOn6eghYq8TGZmJrZt24aVK1faZF64fv16kY8piiIEQShSwQf7zw4aNCjPfNmNGjXC5s2b1bR+CxcuxJAhQ3Dw4EFUqFABALB48WKMHTu2yH1xF0pO4qSkJIf3EhMTUb16dZtt+RX6AawXS3f178knn8RHH32ErKwsPPnkk8U+npadO3eiatWqeab5yu8cFwdXx7xSpUp57nf37l3138UZc+UinJ9HsLBzRKfL+3Lp7L3o6GiULVtW9fDk11Z3eS4jIyPz7A/geBMraN4Xhq5du2LXrl2Ijo5G06ZNUb58eXTv3h2vvvoq9uzZg7t37xbL+CxKW3/44Qc89NBDeO6559Rtive0Xbt2hf6OSpUqOR1fZ9ucUdJj5Or8UFYIMjIyUK5cOXW/O3fuFLltxW2TQn6/w6Ly448/Ytq0aejYsaO6La97sjt/MwoPHjwAz/M2fVPGpHLlyuq2vK4zAHDixAl1tTMvBg8ejMGDByMlJQU7d+7Eu+++ix49eiAhIaFQx8mrLQDQrl071KlTB9988w369OmD1atX4/HHH1cL9B04cAB37tzBggULbO5RRbWBtNdxbS2Cu3fvQhRFj17zPA31oHsZJXWR/SSxT71XGLZu3QqLxWIjQVDSRhX0ROrsswURFBSEbt26YdWqVSCE4J9//kHVqlXRqFEjrF+/vsj9KCpGo9EhtVP16tVRo0YNbNq0yWb7uXPncOHCBXTv3r1Q3+Hu/o0cORKEEPTq1cvmAlxcVq9ejePHj2Pq1KluO6aruDrmUVFRqFevHn755Reb/Xbu3GkjtynOmFepUgXx8fFYvXp1sdtbVB5++GEcO3YMV69ezXe/fv364eTJk6rHzhmK16+gtKzdunXD33//bbN8DwAbN25Ew4YNi+Spz87Odsmj3r17d/z999/YsGGDOnZNmjRBZGQkZsyYAYPBgIceeijPz7vax8JgMpkcrrUbNmzIN+1dfnTs2BFHjhxRvY2AJBn79ddfXfp8SY+Rq/NDkVudPn1a3YfneWzfvt2t7SlMmzyFKIqwWCxuvSc7uycV1IYtW7bYbPv5559RvXr1Au8PPXv2hMFgwLp161z+voiICDzxxBN49913kZycjFu3bhXpOHnx1FNPYdOmTfj5559x69YtG3mLMi7a8c7JycFPP/3kcBxXxrFLly5gGMbhOq6s7hf3Ol6SUAPdy0RERKBjx46YN28e/vrrL1y/fh3Tpk1zuUT0ww8/jK+//hoXL17ErVu38O2332LMmDFo3rw5nn76aXW/r776CuHh4Tb6K1c/64wDBw5g4MCB2LZtG27duoUbN25g3rx5CAkJQZcuXQAAn376Kfbu3Yv//Oc/OHnyJO7du4fDhw/j9ddfx6xZs4owWq7RqFEjJCQk4NChQ8jIyFCNiQ8//BA7duzA22+/jYSEBBw+fBjDhg1DrVq1MH78+EJ/jzv716BBA2RmZjrc8AqDUuwjOTkZhw4dwuTJk/H0009j3LhxeOmll4p83OLg6pi///77ar72mzdvYs+ePVi8eLGD56Y4Y7548WL8/fffGDVqFE6ePIlbt25h9erVNmPj7jmi5cUXX0STJk3wyCOPYMuWLUhMTMT58+fx5ZdfomvXrup+L7zwAho3bowBAwbg119/RWJiopoXX9H3165dG0FBQdi0aRMePHiQZ77piRMnokKFChgyZAiOHz+O69evY/LkyThy5Ag++uijIvWjSZMmDppbZ3Tr1g2CIODAgQOqF5hhGHTp0gV79+5F27ZtERoamufnXe1jYRgwYAD27t2Lr776ComJidi0aROWLFlS5JiPF198EeXKlcMTTzyBU6dO4fLlyxgzZoyq7y2Ikh4jV+dHkyZN0KpVK0yfPl19YB07dqxDvn13nDNPzNnCwLIsHnnkEXz66afYv38/bty4gQ8//LBYlUAbNWqEzMxMbN26Fenp6QU+EFasWBFff/01duzYgVu3bmHhwoVYs2YN3nvvvQJXxitWrIjZs2fjvffew9y5c3H58mXcvn0bO3fuxLBhw7Bt2zYAwMKFC/Hyyy/jwIEDuHfvHs6ePYuVK1eiTp06qFWrlsvHcYVRo0YhJycH48ePR9WqVVUbAQA6deqEiIgITJ06FQkJCTh16hQef/xxm32047h//35cu3bNJg+6lho1auCFF17A7Nmz8e233+L27dv48ccf8eabb2Lo0KF+U8TQGdRALwHWrl2Lxo0bo3///ujVqxciIiLw1ltvuVQRcNGiRerNu3Hjxvjoo48wbtw4/PnnnzaVtfR6vcPxXP2sM9q3b4/nnnsOS5YsQdu2bdGxY0ecP38ev//+O+rWrQtA+uEdPXoUZrMZjz76KOLj4/HKK68gJibGphpYcHCw05tQWFiYQ9CJTqeD0Wi0uUjZVxJ95pln8OSTT2LIkCGoWLGiGhwydOhQbN68GXv37kWLFi3wxBNPoE2bNmr1u4LaExoaqi7LFaZ/zggKCirwIUw5Z9q+Kp/TehuUbbVq1UKFChUQHx+P8ePHIzs7G3v27MHy5cud7u/K0l5xz42rY/7444/jyy+/xHfffYfmzZtj/vz5WLJkCcqUKWMzF4sz5t26dcP+/fuRmZmJvn374qGHHsK2bdvw+uuvF7q9eY2LMjZBQUEO20NCQrBnzx4MGzYMb775JuLj4zFkyBDs378fy5YtU/cLDQ3Fn3/+iSFDhuCVV15B48aN8eabb2Ls2LHqkm1ERASWL1+OLVu2oEaNGoiLi8OlS5ccKk2WL18eBw4cQMOGDTFo0CC0atUKJ06cwLZt29Tfhfbc2V9vlDmonSsZGRkurfLUqlUL9erVQ9myZdUAO0AKdjMajQ7BffZtz6uPhWmrPc8++yzmzJmDDz/8EM2aNcM333yD7777DmXLlrWZZ65+R3h4OP744w8YjUZ069YNgwcPRv/+/dG5c2ebAGdfHSNX5wcArFmzBtHR0ejYsSOefPJJjBgxAq1bt7bpZ17tyQtn15Hizlkg7+ur0Wh0+G06q767YsUK9OrVC8OHD0enTp2QlpaGefPmwWg02gQU5vU9ISEhNteHgQMH4sUXX8S4ceNQqVKlAo1EhmGwdOlSfPrpp2jWrBlWrlyJFStWYNSoUQV+NwBMnToV33//PXbu3ImHHnoIbdu2xbx58/D444+rc+qFF15A/fr18frrryM+Ph6DBg1C1apV8fvvv6vXcFeOk9e4aqlRo4YabPqf//zH5jcaFRWFLVu24N69e2jdujWeeeYZjBs3Dt26dXPo3+zZs9Xxi4uLw+zZs9Xv1/5+Fy1ahJkzZ+Kjjz5Co0aNMH36dLzyyiv49ttvbY7nrN0Mw8BoNDrMS1+AIcV1UVAoFAolILl06RLq1q2L/fv322TIoFAo7mHy5Mn44Ycf1OB+CkWBetApFAqF4pRDhw6hX79+1DinUCgUL0MNdAqFQqE45amnnnI5AJJCoRQeV+SPlNIJlbhQKBQKhUKhUCg+BPWgUygUCoVCoVAoPgQ10CkUCoVCoVAoFB+CGugUCoVCoVAoFIoP4f6auX6GKIpITU1FcHCwX5WApVAoFAqFQqH4F4QQ5Obmoly5cvkWoir1BnpqaqpaDIRCoVAoFAqFQvE09+/fR/ny5fN8v9Qb6Eo1quTk5HxLLFMCF0IIkpKSEBsbS1dRSil0DlDoHKDQOVC68db5z8nJQWRkZIEV3Eu9ga6chJCQEJuy7pTSAyFEPf/0ohxYCIKAvXv3olOnTk5LhCvQOUChc4BC50Dpxtvnv6DvoEGiFAolYBFFEX/88QdEUSzpplAoFAqF4jKl3oNOoVAoFOeIogiLxVLSzfAKhBDwPA+TyUS9p6UUOgdKN544/3q9Pt9A0PygBjqFQqFQHMjOzsaNGzdK1eqDIAjIyMgo6WZQShA6B0o37j7/LMuiSpUqRYpxpAY6hUIJWFiWRe/evYvswSitiKKIGzduwGg0IioqqlR4ExXvmU6nKxX9pThC50Dpxt3nnxCC5ORk3LhxA3Xq1Cn0fYga6BQKJWDhOA7t27cv6Wb4HRaLBaIoIioqqsBMA4ECIQQcx1HjrBRD50DpxhPnPyoqChkZGbBYLAgKCirUZwPGrUQIwbFjx7Bt2zYkJSWVdHMoFIoPwPM8lixZAp7nS7opfgk1UigUCqXoFOcaGhAGelZWFrp27YqBAwfi/fffR+3atfH111+XdLMoFEoJQwjB/fv3QQgp6aZQSiGEEGzcuBELFixAZmZmSTfHa5TWflMo7iQgDPSPPvoISUlJOH/+PPbt24cVK1Zg/PjxuHfvXkk3jUKhUCillHnz5uH999/HnTt3IAgCAGD//v1YsmQJ9uzZk+9nBUHAli1b8Nlnn+H06dNO97l58ybmz5+Pf//912a7q9+xYsUKhxXnL774Anfu3Mm/YwXgrN++RGpqKr744ot898nJycH69evx6aef4vLlyw7vX716FStWrMD8+fOxbds2dTshBJs3b8aSJUtw6tSpfI8/f/58G+eBxWLB/PnzfXLMKN4nIAz0n376CaNHj0Z4eDgAYPjw4TAajdi6dWsJt4xCoZQkCXdy83zPLFjw993TsAilI42gV7CYpf8oAIDdu3dj3rx5mD9/PsqWLYtFixbh8ccfx4kTJ/DUU0/ho48+cvq5jIwMtGvXDsuWLcPRo0fRqVMnrFixwmYfQgjGjRuHDz/8EBcvXlS3u/odAPDee+/hxo0bNtvmzJmDhISEYvTasd++RnJyMubMmZPn+xkZGWjWrBlWrlyJEydOoEOHDti3b5/6/vfff4/mzZtj7969SExMRFpamvremDFj8Prrr+Ovv/5Cly5d8rRDsrKy8Nprr9kY4yaTCa+99lqpSW1KyZ+ACBK9fPkyateurb5mWRY1atTAlStXHPa1WCw2etScnBwA0sWOLoOXTpRzT89/YGG2iJi58gbKhg4Ex3EO5/fXa7/jq7Pf47lGI9Cvejc6BzQo41DoMUm+K/2Nq+TW9qSnp+Pnn39GUlISCCEYO3YsypUrBwA4fvw4jh49iqpVq6Jfv36q5vPbb79Fnz59EB0dDQBYt24dOnbsiEqVKuH7779Hq1atcO7cOaSnp2P48OEAgAMHDuD06dPIzs5Gnz590LhxYwCSR/qff/5BlSpV8PDDD6vZGDZv3owKFSqgVatWDm3+8ccfcf78efz000+4du0aRo0ahdmzZ2PDhg1o3749zp07h44dO+Kll15yqGItiiI+//xzNG3aFADQu3dvvPfee3j++efVfZYtW4Z27drh1q1b6nmyWCwuf4eCs3NMCMHZs2exZcsWm+0DBgxA3bp18z1X9v1+5plnQAjB9u3bcf36dbRo0QJt2rRR9//444/x1FNPYefOnYiLi0Pjxo2xadMm9OrVCzt27EBcXBz69euH8+fPY9euXWjevLka+G0ymbB48WIwDIOIiAj07NkTVatWBQA8ePAAmzZtQt++fbF9+3ZERkbi0UcfBQD88MMPSE1Nxbx58xAeHo5x48bZ9P2nn35CTEwMtm/fDgDo2rUrZs2ahe3btyMrKwsTJ07EunXr0KdPH5vPXb9+HevXr0dCQgLKly+Pnj17YubMmejbt6/Tcbcff+3fPXv24OjRozaf0c57imewPxfuPF5hjx0QBjrP8w7RsUFBQU6fQmfPno2ZM2c6bE9KSipSnkqK/0MIQWpqKgAaFBdI3EsVkJ3LA5YMJCYmOqS4Op90GaIoIiH5BpJCkugc0MDzPARBAM/z4DjOtQ+JInSi5A3kzWbAjakt27VrhwYNGqBatWpgGAYmkwk8z2Px4sWYP38+HnnkESxfvhzLly/HTz/9BEAy/OrXr4+IiAgAkkEbFxeH2NhYrFixAu+99x4aN26MNm3agOd5vPjii9ixYwd69+4No9GIzMxM8DyPyZMn4/Tp02jcuDF++OEHLFu2DBs3bgTDMEhOTobRaHQahHz//n1YLBYkJycjKSkJly9fhsViQevWrcHzPOrUqYOyZcvi7NmzqiGuEBoaivj4ePW4aWlpqFixovr62rVrWLt2LbZv344ffvhBPVeF+Q6Fb775Brt27VJfp6amQhAEZGZmqlIXi8WCr776Cl26dCkw4Nq+3zzPY8SIETh//jzat2+P999/Hy+99BKmTp0KAHjzzTfx448/Ij4+Hv369cPt27fx2muvoXbt2mjevDk2b96MXr164cKFC2jSpAlmzJiBNWvWoFu3brBYLGobz5w5g+nTp2Pr1q2Ij4/H7du38frrr2PVqlVo1KgRdu/ejaNHj2LGjBm4f/8+BEHAnTt3kJ2drfaJEAJBEJCbm4vg4GB1e1BQEA4dOgSe53Ho0CEYjUZUqlQJS5YsQe3atdGzZ08AwKFDh9CqVSuUKVMGPM+jd+/eePrpp2EymRx+R8qx58+fr16bzGaz+l5qaqrat+TkZGzfvh2jR4+mAe8eRDn/gPvuA8q1NDk5GTqdZHIrjuGCCAgDPSYmxkFHl5SUhJiYGId93377bUybNk19nZOTg8jISMTGxlIDvZSiPM3GxsZS4yyASM3Nho67j9rBu1C2XGuEhtg+xGdfzQXLsjCEGBAbGwuAzgEFk8mEjIwM6HQ66HQ6DHvrbMEfIgBkAx1sJlCIYVz3QcM838vKykJiYiK2b9+OKlWqWL+OELz77rs4ePAgGjZsiNzcXNSrVw/Hjx9H27ZtwTCM2n5AuuFqU6iNGDECb7zxBgDJuNu0aRNOnz6NqKgo9TvOnTuHn376CVOmTAEAVKtWDR9++CESEhJQu3ZtPPPMM3m2+/nnn8c333yDl19+Ge3atcPBgwcRERGhtgcAypcvj5SUFJtt9ly+fBkffPABfvjhB+h0OhBCMHHiRCxZsgTBwcE2/UpNTS30d6SkpECv16uvBUEAx3Fo3bo1WrduDUIInn32WSxfvhytW7fOs5159fvEiRPYv38/rly5guDgYFy4cAEtW7bE1KlT1TbNmTMHHTt2BACcP38eubm52L59O8qWLYvOnTtj2rRpuHLlCvR6PWrWrIktW7agV69eCAsLw9SpU/Hbb78hOTkZd+/exYYNG9C0aVPodDrk5OTg559/RkREBI4fP46xY8di1qxZeP7557FhwwYsWLDAaR8GDx6MGTNm4LnnnkPVqlXx+++/IyMjAzzPq7r65557Ds2bN8fixYvRsWNHfPHFF0hJSUFkZKTar8jISACSZEY7rwCo+9y7d0+95ihORZ1Oh4EDB2LgwIHIzs7GwIED8csvv6irQRTPov09FBfl9xQVFaU6kkuVgd6pUyds3boVzz33HADgypUruHTpEjp16uSwr16vdzr4DMPQG3MpRjn/dA4EDulZGm2nhcAYantu7+emSO+JFpvzT+eA1XvkrfHI7zvCwsIwffp0tG3bFmFhYRg2bBjeeecdpKSkQBRFxMfHAwBCQkLQvHlzXL16Fe3atXPafu3rli1bqv++dOkSmjZtqsoHlO0XLlxAcHCwjQPomWeeQVBQkMvjonxn+fLlkZaWZvO5tLQ0REZG5nmsCxcuYODAgfjyyy/RokULAMDatWtx//59/Pbbb/jtt99w7949/PDDD4iJiSnSd0yaNMlGorNp0yabcZo2bRqaNGmCkSNHutRf+35fu3YNTZo0USU29evXR3BwMO7cuaPKUbTngmEYVKlSRT0XMTExqFevHgwGAwDpIfrcuXNgGAZnzpxBly5d0Lt3b8TGxsJkMuHBgwfqd1epUgXly5cHAMTFxSE1NdWmb/ZjQggBwzCIiYnBP//8g9WrVyM7OxszZ87E0KFDERISgsjISCQmJuKff/5BmTJlcPfuXVSoUAELFy50GP/MzEwQQhAREeHwXcrrjz76SDXWMzMzVckOwzDgeR4jR47Ea6+95tLDEaV4KOcfcJ8H3dm11NVjB4SB/vbbb6Ndu3Z4+eWX0bRpU3z88ccYPHgwWrZsWdJNo1AoJURapnUp2GRx1Ngm5zwAAJgFGtRYEOvnxBe8k9kEJMuGbGQMEOS+AkevvvoqpkyZgnPnzuG5555DnTp1MGrUKIiiiOvXr6N69eoQBAFnz55F5cqVAQDh4eFISZEewniex7Vr12yOqZU8VatWDWfPnoXJZLLxNFerVg25ubmYOXMmjEZjsfpQo0YNCIKAU6dOoXHjxkhISEBSUhLq1KnjdP/Tp09j0KBBWLVqFTp37qxur1y5Mrp27YrExEQAktc1JSUFOTk5qF+/fqG+oyAWLVoEQoi6glAUKleujPPnz6sVGm/evInMzEx11QpAkSv9btu2DaNGjcLHH38MABg3bpxL+l6dTgdRFPPdJy4uTu33K6+8gl69egEAmjZtCoPBoDr6lIc1QRDQrFkzHD16FFlZWTAajdi9ezcaNWqU7wpJfowbNw5Dhgyx0bpTSg8BYaA3btwYhw4dwvLly7Fjxw6MGTMGEyZMKOlmUSiUEiQ1U/KgZ4lRMNsZ6JmWLJhkw9xEDXT3oDV4SP7GT2FITU3FypUrAUjBooq8hOM4TJ06FX369MGTTz6J/fv3IzY2Vl057dGjB15++WUMHToUhw4dyndZuUWLFmjbti26du2KAQMGIDQ0FH369EGLFi3QtWtXdOjQAY899hiMRiNYllUNt/yCRO0JCgrCyy+/jMceewzDhg3Dhg0bMGHCBDX7mJZ79+6hW7du6NSpE44cOYIjR44gNDQUL7zwAjp16mSzOrxz5048//zz6qqBq99REFu2bMEHH3yAV199FfPnzwdgDRItTL/btGmDWrVqoXfv3ujcuTPWrVuHyZMnF7qqojOaNWuGuXPnomzZsvj333+xbds2DBkypMDPVahQAampqZg+fTqqVKliEySqsGjRIuTm5uLvv//Gjh07cOjQIQBApUqV8Pjjj6N3797o3bs3Nm/ejMcffxyRkZGIjIxE165d0atXL3Tr1g1ffPEFFi5cWKS+zZkzB8eOHUODBg3U8adBoqWLgDDQAclIX7p0aUk3g0Kh+AhpmTwIOFw3dwUv2HroFO85QA10t6E1ykX3ZcMRBEH1FpcpUwYbNmxQl/tnzZqFtm3b4ujRo3jyyScxcuRIdfn4rbfeQtWqVfHvv/9i9uzZOHjwoOpdHzp0KKpVq2bzPevXr8f333+PU6dOIT09XTXo16xZg82bN+P48eNITEy0CfZLSUlBmTJl8mz7k08+iYoVK6qv3333XTRq1AgnTpzA9OnT1ewxzhg9ejQAqH3Py4M/evRom74U5jvGjx+PuLg4m21jx45FxYoVkZ6ejlGjRtnIe0wmEwBg7ty5TpMtKNj3e+vWrVi9ejWuX7+Ojz76SM2mAkjeaa2HOTIyEs8++6z6ulq1ahg6dKj6ulGjRqpcpkePHvj6669x8OBB9OnTB2PGjEFycrLT44SHh6tZcIKCgrB9+3b88ssvedZLSUpKgtlsRuvWrfF///d/NuP0+eefY/Xq1bhw4QKmTJli077169fjf//7HxISEvDtt9+qAaT2hIaG4tVXX7VZPTAYDHj11Veh0+lQoUIF9OrVSz3/AGh+9FIGQ0p5XrGcnByEhoYiKyuLBomWUgghSEpKogGCAcaC727g8OlUxOpO4/nRj6BxbashdTTxBGYfWQwAaBhZB7M7TKNzQIPJZMLVq1dRs2ZN1z2dWZlAmvzgUyYCCCu817YkIYSoMgw6B/LGYrFg5cqVAblKTedA6cYT59/ZtVSxO7Ozs/NMfwoESKEiCoVCsSc1gwcDgijdReTm2qYmu6fxoJtpoSL3QDwjcaH4Fnq9PiCNcwrF16AGOoVCCUjSs6xGea6dBp1KXDyAVoNeQAAehUKhUPKHGugUCiUgScvUpFk02xqM1ED3ANSDTqFQKG4jYIJEKRQKRcFsEZGdKwBgcNvSHBbeVk+YnEsNdLejDWeiHnQKhUIpFtSDTqFQAo40tUgRixShFkx21bGTc1LUf9M86G6CSlwoFArFbVADnUKhBBxpGZJFzkBA3aAtyMm1GuEiEdUqogBgEkwuFTehFIBNHnQ6nhQKhVIcqIFOoVACjlRNFVE9k2OjQedFAYIoQMdy0LEcRELAE97ZYSiFgUpcCuTevXtYsGBBSTejUKSkpOCjjz7CO++8U9JN8QhXr17FrFmz8NlnnwEAdu3ahbfeegt79+51y/FPnDiB7777zi3HcheXL1+26XNenDlzBl999ZXDv0sKT4/liRMnsHr1apf2dXUMiwM10CkUSsChzeACALkmq8EoEEn+wjEcgjgpLy1NtegGPFRJ1Ne4f/8+PvzwwyJ/9ssvv3T7cbOzszF16lSH/+zZvXs3pk6diuzsbJePPXr0aJw+fRqxsbFFapunOXXqFL7++usifZYQgt69eyMrKwsRERE4ffo0xowZg/Dw8DwLQxWW8+fPY/PmzW45ljsQRRG9evVS+5wfly5dwsaNGx3+7S3sz62nx/L8+fPYsmWL0/e0Dyj2Y7ht2zb8/vvvbm8PNdApFErAoUhcyoVJVR9NFqvBKMrGI8dyCOIM0vtUh158iJ0GPUBlLikpKVi5cqVPHTc7OxsLFixATEwM4uLi1P+03L9/H9OnT8eCBQsKZaAfPnwYS5YswQsvvFCktnmaCxcu4Oeffy7SZ5OSkiCKIubOnYsnnngChw4dwqBBg/Dmm2+iRYsWbm6pb5CUlASGYdQ++zLFObfuJigoSH2gsR/Dffv24eDBg27/TprFhUKhBBwZ2ZKXPKpcCM7dHIgWFmsWF0HUetCtBjr1VhQTe4OcEMCN1RgPHDiA3bt3IyUlBa1bt8awYcMAAL/++iuOHDmCqlWrYuTIkWq1vs8++wwdOnTAkSNHkJOTgxdffBHvvPMOnnnmGfzyyy+oWLEiHnvsMeTk5GDNmjW4fv06GjZsiKFDh6pVBHNzc7F27VpcuHABFosFkydPxsqVK3H//n1MnToV5cqVw/Tp09VjJCQkoHHjxhgyZIh6jDt37uC7775DaGgoWrZsmWf/nB03JSUFq1evRkpKCnr06IH27dvnO0ZTpkyBTuf8tv7SSy9hzpw56NKli8tjPmvWLKSkpOCdd95Bq1atMHLkyDzbdO/ePXz55Zfo378/fv75Z/Tu3Rssy+LMmTOoVKkS/vjjD7Rq1QqPPPIIfvzxR/zzzz/o27ev+vkrV65g2bJlYBgGcXFxGDp0KKpUqQJAkh6cOXMG1atXx65duxAfH4/HHnsMZrMZX3/9NS5cuICpU6eiYcOGePbZZx36cfXqVfz0008QRRGDBg1C3bp1kZGRgenTpyMtLU1dbfjrr7+Qnp6OqVOn4tVXX0XFihULHKOsrCz8/fff6NixY777/fHHH/jzzz/RvHlz9O/fHwBw6NAhJCYmYtCgQer3X7p0CcOGDVP77MrYKftWrlzZ4Tu0ZGRk4L///a/a50ceeQTdunVzOj4FkddnPv74YwwbNgwVKlTAjh07cObMGUyePBkAMGfOHEyYMAFhYWH4/vvvcerUKZjNZnTv3h0PP/ywzfGdnVul2vv+/ftt5oHC3bt3sX79ety/fx+dO3dGt27dnLad5/l8v3///v3YvXu3zfFNJhNSUlIcxrBly5b4/fffwXEcUlNT0bNnT/Tt27fA8XMFek+iUCgBh4WXjMUwI4tgJg25Wg26KnFhYaAedPdAiNVAZ6VVC3fq0BcuXIgnnngCWVlZiIuLQ9myZQEAM2bMwCuvvAJCCL777jv06NFDDfhdv349nnjiCZw9e1b1fC1duhTDhw/HvXv3UKZMGeTm5qJLly44evQoDAYDPvvsM4wfPx6AVI67VatWWLduHcqUKYO4uDjo9XpERESA4zjExcUhOjra4RjLli1Tj5Geno42bdrg5MmTuHHjBsaOHZtnH+2Pm5GRgebNm2Pfvn3IycnBwIEDC9TfTps2TZW3aLXu33//PWJiYtC5c+dCjXt0dDQYhkFsbCzKli2bb5vu37+PDz74ABMnToQoiggJCcH58+fxyiuvYNGiRRBFEaNHj8aAAQOwadMmWCwW9O3bF1euXAEAGAwGxMXFISYmBjdv3kSHDh1w7949AJL04PXXX8f8+fNBCMGrr76Kr7/+GgzDICIiAkFBQYiLi3Mq2Th37hxatWqF69ev4/bt22jTpg3++usvcByH6Ohodczj4uJUaYtyrl3hzp07GDlyJP7444889/nzzz/x0Ucfged5TJw4EYsWLQIgGdY7d+5U9zt79iy2bt2q9tnVsTt//jxee+01p9+hxb7PRqMxz/HJj/w+o+3DokWLMGfOHOTk5CA5ORmLFi1CuXLl8P7772Pp0qXq7yo8PNzhO/I6t3v37nWYBwDw77//omvXrkhISADLsnj55ZexbNkyp+3P7/v379+PBQsWOBxfkfjYj6EyZ8LDw/PsS1GhHnQKhRJwiLKRFhoE1AjaA7N5hOY9yXBkGVbjQTchBK7dkEslMyfm/z4BIK9MgJFfs6zrHvR3Fuf5liiKeOedd3DkyBE0aNBA3S4IAubPn4+zZ8+ievXqEAQB9erVw969e1VDdPz48Zg0aZLN8ebOnat6kb/66ivk5OTAaDQiJSUFjRo1whdffIHly5djzZo1iI2NVY0NhSFDhuDzzz9Xva72x2jcuDE+//xzLFu2DGvXrkXbtm3xzTffAADi4+Pz1JnbH/ezzz5Do0aNsGbNGgBA+/bt8dZbb2HkyJF5jlVsbCxYVvK7RUZGApC8igsXLiySRnbChAl47bXXMHnyZAQHBxfYJovFgg0bNqBMmTIAgJMnT6JatWr46aefAEjn7MyZM6rRc/v2bezZswe1atVClSpV0Lp1a+zduxc6nQ5lypTBn3/+iSFDhgAAKlSogA0bNgAAatSogd9++w1PP/00Hn30UWRlZTnV3APA4sWL8cILL+D9998HAERFReHjjz/G119/jTFjxmDDhg3qZzmOw40bNzB16lR1BUTLypUrcf78eYft9evXx6OPPoqDBw8iPj7e4f3w8HD88ssvYBgGgwcPxoABA/Dyyy8XOP6ujp2r3xEaGurQ5xdeeCHP8cmL/Ma0e/fu2Lx5M55++mlcvnwZjz32GPbt24eUlBR07doVgLRa0qtXL7zwwgvqXLFHr9c7nNu1a9fmOQ8WLlyIChUqgBCCtLQ0NGnSBF9//TUmTJjgcOz8vj8uLg4//fQTGIaxOX5+Y3jo0CEEBwfnOQeLCvWgUyiUgEOQbcXQIFmDrvGgKxIXHdWguxGtvMV9shZA8swKgmBjnCvbWZZF9erVAUjGVXx8PG7evKnu07BhQ4fjabddu3YNUVFRqge1UqVKePfdd0EIQUJCAlq1alVg++yPUblyZcycOROEENy4cQONGjVS99X+uyBu3rxps3/Tpk1t+uaMKVOmqB70//znPwCADz74AEajETNmzFANiHfeeQf//vuvy21xtU2VK1d2MHgUAxIAypUr5/A6IyMDAPDll1/i2WefRXZ2NmJiYhAWFoaUFGs61Nq1a6v/joiIUD9X3DYXhoiICBuNv/JfSEgIgoODERwc7PRzDRo0UA3++Ph43L5926XUrq6OXXG+oyjjk99nunfvjl27duHIkSNo3bo1evbsiZ07d2Lnzp3o0aMHAODdd9/F33//jcqVK+Ohhx7CoUOHCmynQl7z4Nq1azbnpHnz5nj++eedHiO/79eOcWHmmSegHnQKhRJwKB704GDJB6GVuAhKkKhGg06LFRVAPh5uAIDFDNxLBHR6gOMAUy5QPgoIDi32V0dFRSEkJATHjx+30XBHR0eDZVmcPXsWDRs2hMlkwt9//4233npL3ceZF1S7rV69etiyZQteeeUVsCwLnueh0+nAMAzq1q2LpUuXghBi8xm9Xg+e550eg+M4m++qVasW1q9fr74+cuRInv20P27NmjVtvJiHDh2yMR5cpW/fvqhcubLNttjYWJclHFoKapOz8XaV33//HTNmzMDo0aMhiqLL6fTsx81Zm48cOYLhw4c7bXNhULz5Ws6ePYtFixbht99+y/O4J0+ehMVigV6vx9GjR1G9enUwDINy5cohKSnJZr+iktd3FERRxie/z8TExCA6Ohoff/yxqnGfO3cu7t+/jzfffBOA9LvYuHEjeJ7HqlWrMHnyZKdGekHnVku9evVw9+5dl7zYrn6/qxSmnYWBGugUCiXgUOTPxmAdMoRYmCxWTxJPnAeJgnM4DMVVlAFnWek/ABDdk8WFYRgsXLgQffr0wcCBAxEREaEGib733nvo2bMnBgwYgMOHD6N58+Zo27aty8ceOnQoVq1ahebNm6Nz584wGAyoWrUqJk+ejGHDhmHFihVo3bo1HnroIej1ekyePBkVK1ZEdnY2xo4di+rVq+ONN95Qj9GlSxcEBQWhSpUqmDRpEoYNG4a5c+eid+/eqFSpEk6cOJFnW+yPO3XqVPzf//0funXrhlq1auGnn34qMJ3gtGnTbIyyd955B3379rUJWnvttdfwwgsvICoqCgDw4YcfYsiQIahTp06B4zV8+PBCt8lVOnXqhLfffhtHjhzBsWPHkJaW5tLn4uPj8ccff2DixIlo3ry5Q5Do5MmT0a5dO9y4cQM6nQ47d+7Evn373NJmAKhTpw62bt3qVNqiwDAMunTpgsaNG2PDhg2YP38+AKBr166YMGECnnrqKZhMJly4cAHNmzcvUjvy+o6CKMr4FPSZ7t27Y9GiRVi4cCHKly8PQghEUUSNGjUAAMuWLcOVK1cgCAL+/PPPPGMj7M+tEiTqjNdeew0dOnRAt27d0KxZM3Ach7Zt2zrNVOPq97tKkyZN8MorryA9PR29e/d2W5AoNdApFErAIQiScWgM1eNfSycEs1ajxZpm0S5IlBroRUdJscgwGgPdfUGio0ePRtu2bbF3716kpaWpQaKTJk3CQw89hGPHjmHAgAE2N8Zx48Y5ZKOYNWuWTX5rnU6HHTt24Pfff8fZs2eRk5Ojard1Oh12796Nbdu24dKlS+B5Hnq9Hnq9HgcOHMCOHTvAsqzNMc6dOweTyaQeIyQkBIcPH8amTZsQGhqK2bNn47fffnPaR/vjBgcH4/Dhw/jll1+QkpKC119/Pc/sGkajEfPmzXPYbu/RB4B58+apY5Cbm4tly5apchhnfPDBB6q3Pb82xcTEYNq0aTafbd68OcLCwtTXXbt2RVZWlvp64MCB6rkcN24catWqhStXruC5555DcnKymnvd/jgNGzbEM888A0CSPPz22284dOiQ0yDR6tWr4/Tp09i6dSsIIfj444/V40ZFRdm0uXPnzkhNTc1zLJyh1+vzNc6bN2+ORYsWoUaNGti/fz/GjBmDNm3aAJD0zn/99Rd27NiB2rVro0KFCkhISCj02AFAmzZt8N///tfhO+yx73N+49OoUSN1nLX/zu8zAPDcc8+hbt266srN7NmzkZOTo75fvnx5ZGVlwWAw4JFHHlGlL/bYn9uGDRvmOQ+io6Nx6tQpbNu2DdeuXYMgCDbjoyWv72/evDlCQkKcHl/bf/sxHDx4MEJDQ3Hu3Dm3BokypJTXuM7JyUFoaCiysrLyfTqjBC6EECQlJSE2NrZYS7QU3+H/Vt/EwVNpeOmJCvhhw69IEpph7ex4MAyDK6kJePXPWahZtirqRtTEtut78HzjkWgR0pDOARmTyYSrV6+iZs2aatrCfMnOAlLvAyGhAKcDMtOB8LLSf34CIcRG4lIauHXrFq5cuVJsD2Kg4K9zYO3atdi4cSPWrl1b0k3xazxx/p1dSxW7Mzs72+aBwB7qQadQKAGHIMsrOBaI1F1BEt8EFp7AoGfsKolSDbpbUD3omswtpdv34xdUqlQJlSpVKulmUIqJvbedEhhQA51CoQQcqoGuWeE3WUQY9KxqoLM0D7r7UDXo/uN1pFAChXr16qFevXol3QyKm6FpFikUSsBBnNiLuSZpoyBaNeg0zaKbULzlDL2lUCgUijugV1MKhRJwWD3oOmQGtQcBg1yztE0JEtUxOipx8QjKUxGVuFAoFEpRoQY6hUIJOBQDXa9nwRprAWDVYkVU4uJJGGqfUygUihugBjqFQgk41BTcAo+QlO/BQFANdF6UCkpwtJKoG1EkLiXbCgqFQgkUqIFOoVACDiUPOsMCDDEBAHItkoGuSFxYhmrQ3Qb1lrvE7du38dprr5V0MwpFQkICXn755TzLplPy5uDBg1i0aFFJN4Pip1ADnUKhBBxKUhGOs7p0VQ+6qkGnaRY9Q2BrXJKSkjB58uQifTY9PR1bt251+3EzMjIwfPhwh//s+eGHHzB8+HBkZGS4fOxnn30WISEh6NevX5Ha5mkOHz6Mjz/+uKSb4ZSEhAQcOHCgpJtRIL48hu5m3759mDhxIiZMmICDBw/avGexWLBy5Ur85z//wfDhw21+q1evXsWUKVMwduxY7Ny50yttpQY6hUIJOEQ5qwirKTaRa7b1oHPUg+5GFGOcCXiZS0ZGBn755RefOq7JZMK6deswYMAADBo0SP1Py40bN7B48WKsW7cOJpPJ5WOfPHkS//3vfzF48OAitc3T3Lhxo8DS9JT8KS1juGfPHgwYMABVq1ZF3bp18dhjj+HkyZPq+yNGjMCqVavQrl07DBo0CLVq1QIAZGdno2PHjjCZTIiPj8fQoUOxf/9+j7eX5kGnUCgBhyJx0et1qNh0LM4cTslXg24WLSXT0EDGzQ709evXY/fu3UhJSUGXLl0wYcIECIKAL774AkeOHEHVqlUxceJEtdz77Nmz0aVLF+zatQuCIGDmzJl4/vnnMWHCBKxbtw516tTBmDFjkJycjE8//RTXr19HfHw8JkyYoFaVTk5OxvLly3HhwgVYLBZ88MEH+PDDD5GUlIThw4cjMjISS5cuVY+RkJCAxo0bY9y4cWqFwHPnzmHFihUIDQ3Ns6Q5AKfHvX79OlasWIGUlBT06tULQ4YMyXeMhg4dCp3O+W19/PjxWLRoEZo1a+bymI8fPx5paWl49tln0bFjR7z88st5tun27dtYsGABBgwYgO+//x7Dhw8Hx3E4evQoypcvjz/++AOtW7fGmDFjsGTJEvzzzz/o37+/avifPXsWs2bNAsMwiIuLw9NPP43mzZsDkKQiR48eRcWKFbFjxw7Ex8fjxRdfBM/z+Pjjj5GQkIDhw4ejRYsWeP311x36ceTIEaxevRqiKGLYsGF46KGHnB63YcOGGDduXJ5jaM+9e/ewd+9ePPbYY/nut2bNGuzZswfNmzfHuHHjwDAMdu7ciRs3bqjl4/ft24dTp06pnl1Xx03ZNzo62uE77MnOzsbSpUtx6tQpmM1mDBw4EI899pjDGPbv3z/PczFx4kS88cYbaoGrQ4cOYe/evXjttdecHv/JJ590aEde55OTC1dcvHgRq1atwv3799G5c2eMGjUKDMO4NEdiY2Oxc+dOvPPOO6hcubLN965btw4vvviiKjMzmUxYvHgxVq5cif379+OPP/7ApUuXULZsWZvx+/7771GnTh0sXbpU3fbJJ5+o88hTUA86hUIJOJQgUZYBxJw7AACzxTbNIsewMHBS6WXqQXcTNjaB+yz0N954AzNnzkTjxo0xaNAgtGjRAgDw0ksv4csvv0Tbtm1x8eJFdOzYERaL9LC1e/dujBkzBmXKlEGnTp0AAD/99BMmTpyIWrVqoWnTpkhPT0f37t3BcRw6d+6Mv/76C6NHjwYApKamonnz5khISEDv3r0xaNAgREREoH379jAajRg0aBD69OnjcIzjx4/j6aefBgDcvXsXnTp1QkhICCpVqpSvhMX+uPfu3UPr1q3B8zyaNm2K1157rUA988iRI1V5i1brvnz5crRt2xZNmzYt1Lj369cPHMfh0UcfRevWrfNtU3p6OpYvX45PPvkEbdq0QZUqVZCQkIC3334bR44cQZs2bfDee++hY8eOSEpKQsuWLTFmzBicOnUKABAVFYVBgwZhwIABqFy5MgYNGoSbN28CkKQi77zzDnbt2oW2bdviiy++wPLly8FxHFq3bo1KlSph0KBBaN++vUMfjhw5gr59+yIuLg5Vq1bFo48+it27dzs97qpVq/DZZ5+5PD5msxnTpk3DDz/8kOc+27Ztw86dO9GqVSt89tlneOeddwAAly9fxvHjx9X9rl+/jsOHD6vtcnXcEhISMGPGDKffYc+MGTOwb98+dT7Hx8c7HcP8zoXRaMQXX3yhHnP+/PmoUqVKnsd3Rl7nE5Ae1B577DFUqFABHTp0wKpVq/DBBx8AcG2O7N69G127dkV4eLjD94aHh+P27dvq61u3buH06dMApAekvn374quvvsKYMWOwYsUK8LzkzDlz5gzatWunfq5du3Y4c+aM0765E+pBp1AoAYeopnERkXhxCxgMVrcpaRY5hkMQqwdADfSCGPTzmPx3IKJUrEgpVEREgGFcLly0ccAXeb4nCAI+/vhjXLp0STUEAEkv+sUXX+DGjRuIjY3Fc889h0aNGuHPP/9UPdWvvvqqQ3DjwoUL0aZNGwDAihUrkJOTg1OnTuHUqVMQBAGbN2+GKIpYu3YtWrRogc8//9zm8126dEFYWJiq8bY/BiFEPcb69evx8MMPY86cOQCAChUqYMaMGU77aX/cJUuWoFu3bpg3bx4AoH79+njhhRfw8ssv5zlWAwcOBMtKY16uXDkAkuG3evVq/P7773l+Lr/j6XQ6PPHEEwgODi6wTRzHYc2aNQgKkh58Dx48iObNm6tG/O3bt3HhwgXV4Pr7779x8OBBNG7cGFFRURAEAXv37kVaWho4jsP+/fsxbNgwAECjRo3w6aefApCMxE2bNuHFF1/EQw89hBs3bjjV3APAZ599hqlTp+KNN95Q2/jZZ5+hW7duDscNDQ3Fxo0bMXHiRIfjfPjhhzhx4oTD9piYGIwYMQLVq1dHq1atHN6vXr26atB26dIFnTt3xqxZswoaepfHrTDfkZqaiqpVq6J169Y2lUftx1AUxTzPxYQJE9CtWzdMnz4dd+/exbFjx7BmzZp8j++MvM7n4sWLERISourD9Xo9NmzYgLfffrvAOVKnTh3V0HfGSy+9hA4dOqBTp07gOA6CICA9PR2AtBqybds2REREoEOHDupKwJIlS5CWlmbjjQ8LC0NaWlq+/XMH1ECnUCgBh1qoiNVuk/8qHnSW0+RBd12TS/EuKSkpYFnWxjhXtuv1esTGxqrbatasibt379q8tke77fbt26hXrx4GDRoEQggEQVDlComJiS6VT9ceQ0GRH9y9exc1atRQt2v/XRD2n61Vq5ZN35zhTOIyd+5cmEwmPPXUU+q2559/Hh999BFq167tcntcaVPFihVV41y7TcFoNDq8zs7OBgAsXrwYX3/9NcaMGYOIiAjcuXPHJphVkVTYf86VNmulRbVq1bLR+rt63Pbt26N69eoO2zds2IDExESb42jRfqZ69eq4f/8+CCEOEhRRiWyXcXXcCvMdH3zwAWbNmoV+/fpBEAQsXboU/fv3d2hzfueiWrVqaNy4MbZt24YTJ05gzJgx0Ov1hTo+kPe43759G23atFFXvQCgTJkyBbYLcP5711K1alWcP38eBw8eRHBwME6dOqXOhdjYWNSpUwcLFiyATqdD8+bN0b9/fyxZsgSxsbE28/zu3buIi4vL97vcgV8Y6CaTCTk5OerrMmXKqF4CLYQQmEwmBAcHe7N5FArFx1CMcZa13qCUwFFBtBYqokGirpGfhxsAkHofyM4CypaXZC6pD4BQI1AustjfHRUVhYiICOzYsQO9evVSt8fExCA0NBQHDhxAhw4dkJaWhsOHD+O9995z+djNmjXD+vXrMWDAAISEhIDneeh0OjAMg6ZNm+Ldd9/Fe++9Z2N0BgUF2QRZao+haNcVGjZsiKVLl+Kdd94By7LYsWNHnm2xP27Dhg2xcOFCtU3bt29Hw4YNXe6bwn/+8x906dJFfb1u3Tr069dP1eoXBne1yRlHjx7FCy+8gDFjxiAnJydPmYY99uPmrM07duxQtdBFbbN2DBVOnjyJt956C7///jsqVKjg9HNHjhxBZmYmwsLCsHPnTtSrVw8Mw6B8+fK4fv26ul9xgg7z+g57YmJisGTJEgDAjz/+iFmzZqF///4OY1jQuVA83ZcuXcKff/5Z4PELQ7NmzXDy5EkMHTrUwc4r6hzREhYWhl69eiE9PR3jx49XpWDdunXD8uXLYbFYoNPp8O+//6Js2bIAgM6dO6sPtSEhIfj++++dzgd34xcG+qpVq/Dmm29CFEVkZGTg2rVrDk+yM2bMwMcff4ycnBw0atQIX375ZaGCYSgUSuAgqh50BmUiawK3tB50q8TFQNMseg43BomuWLECw4cPR6tWrRAREaEGiX7yySd49NFH0b59e5w8eRKPPfZYoXTWgwYNwsaNG1G7dm20bdsWer0etWvXxgcffIBBgwZhzZo1qFu3Llq1agW9Xo8PPvgA1apVA8uy6Nu3L2rVqoUlS5bYHCMoKAi1atXC7Nmz8fjjj2Pp0qVo2rQp4uLikJubm2dbKlasaHPcRYsWYeXKlWjcuDGqVauGY8eOYdOmTfn2Z+TIkTaG2YoVK9C2bVu0bdtW3fbkk09i8ODBiIyUHp4mT56MsWPHolGjRgWO1xNPPFHoNrnKgAEDMG7cOPz88884f/48DAaDS59r3rw59u7di8GDB6N9+/YOQaJTpkxBp06d0L59e+h0Oty6dcvGqCwOTZo0wb59+2y82/aUL18eHTp0QJUqVXDgwAF8++23AIBevXph0qRJ6NatG8xmM1iWVbOGFJa8vsOeWbNm4ezZsxAEAUeOHFHlX/ZjWNC56NWrFyZOnIh27dohJiamwOMXhtdeew19+vRBgwYN0KRJE3Ach+7du+P5558v8hxRSEpKwqRJk2A2m3H48GG0a9dOjRdp1aoV2rVrh6ZNm6J+/frYv3+/Khvq0aMH6tati6ZNm6JChQq4fPmyGi/gSfzCQJ8wYQImTJiA8+fPo0GDBg7vf/nll1i6dCn27NmD+Ph4vPXWW3j00Udx6dIl6k2nUEohijFuMOhRPb4vDt66qxrtSpCojuWgYzmwDAOREHU7pQhosix6Ig96//79cf78eRw7dgxpaWmqzGLEiBHo1KkTTp48iapVq6JJkybqZ6ZPn+5wv/j888/V5XIAYBgG//vf/3Du3DmcO3cO2dnZiI6OVt9bv349Tp48iUuXLoHneURERIDjOPz999/Yv3+/KiNQjnH+/HmYTCaUL18eAKDT6bBr1y7s27cPoaGhqFevHg4dOuS0j/bH5TgOv/32G44cOYKUlBS0bt0aUVFRTj9bpkwZVQesxV5uAkgZRZQxyMjIwJYtW/Duu+/mNfT43//+pxpC+bWpUqVKWLhwoc1nO3TogGrVqqmvH330UZvV8NGjR8NoNAKQ5DmNGjXCtWvX0KJFC9y6dUsdR/vjtGjRAlOnTgUAVK5cGSdPnsRff/3ldHxiYmJw4sQJHDp0CIQQtGvXTl3pcHbcKVOm5DkW9jAMk69x3qFDB3z++eeoWbMmjh8/jk8//VT9vnLlyuHMmTM4ePAgatWqheDgYCQmJhZ63ABJz/3JJ584fIc9HTt2RN26dWEwGPDee++hfv36ABzHsFOnTnmeC6XfFSpUcIiHyOv4zsYlr/MZFhaGffv24fjx47h27RoEQVAfXAozR5yhBGFzHIfp06erweYK3377Lfbv348HDx5gxYoV6rllGAa//vor9u7di/T0dHTp0sXmOuIpGEKI31STUAx0ew96x44d0b59ezVwJSsrCzExMVi9ejUGDhyY7zFzcnIQGhqKrKwsh+VJSumAEIKkpCTExsY6XRak+B/Pzb6AtEwen06rhTXrNmHf9Ybo3ykGTz0cix8ubsG353/CkDoP46kGQ/D4L8+DFwUsaTULlSpUpHMAkqzw6tWrqFmzplMjz4GUZCAnGyhXHgAjSV5CQoEI5walL0IIsZG4lAbu3r2Lu3fvuuQ9Lw344xxYu3YtNm7ciLVr13rl+37++WfMnz8fRqMxz6Jb/oonzr+za6lid2ZnZ6vpWJ1RYh50e125PQaDwWWDWckdqmA0GlGnTh2cOnXKwUC3WCxq6hwAahsIIfCjZxWKG1HOPT3/gYOaxUUU8SDxPIAGEEQRhBBYlDzoDCt5KhkOPAQIIk/ngIwyDoX/XWhuagRSZhc/Qtvv0kB0dDSio6NLTX9dwd/mQPv27VG1alWvtbd27dp49dVX0bNnT78Zo8Lg7vPv7Frq6rFLzEBfvHgx3n///TzfHzJkiE2uzfzIyspyWG4oW7YsMjMzHfadPXs2Zs6c6bA9KSmJetBLKYQQpKamAoDfeE0o+WMy8xAEggcPkgEAgiAiPT0LSUlJSM9IgyiKyMrMRlJSEohIIIoiHqSmwMAZ6BwAwPM8BEEAz/Nq8ZD8YEURrJwFBQA4Io2pqHGG+DpE0346B0on/jgHKlasiIoVK9o4Hj1JnTp1UKdOHQDw2nd6C0+cf+VampycrGZYys85raXEDPSpU6eqmqPiUqZMGdXAUkhJSVEjcLW8/fbbmDZtmvo6JycHkZGRiI2NpQZ6KUV5mqUSl8CBZVPAcSJiYyQ9McexCA0NRWxsLEIehIJlWUSUKYfY2FgYdAaYiQXhZcPpHJAxmUzIyMiATqdzraoiwwIMIxnzDACGAcsyYF2syOhLKCnjKKUXOgdKN+48/4IggOM4REVF2UhcXMH/rp5OaNGiBQ4ePKjmeU1NTcWFCxccAgAAaeCdDT7DMPTGXIpRzj+dA4GBqAkSrdu0H84cZiGI0nlWK4myLBiGAcdKHmIRhM4BGe0YFGo8bIJEIRUr8hO0eaPpHCid0DlQuvHk+dfeW1w9tl8Y6DzPIzMzU01In56ejtTUVISHh4PjOEycOBEjRoxAz5490bRpU/z3v/9FrVq1bIoTUCiU0oMgr4ro9RxiKtUBcBuKLJ3XpFmU/kq5dmkWFyt6vR4syyI5ORlRUVEF31AsFoAXALNFes0LgIUH8slP7WsoAWKCIFDjrJRC50Dpxt3nnxCC5ORksCxbJK+8Xxjohw4dUpPdly1bFp07dwYA7Ny5E61atcLAgQOxaNEi/Pe//8X9+/fRrl07bN261bWlWQqFEnAIglyUiLfgwLalYDDAIc2ivYEuUANdRanceePGDZtKfXmSlSEZ6anp8utMQK8HHqR6tJ3uRlmOppRe6Bwo3bj7/CvXUmfFNQvCLyzYjh07OmjM7RkzZgzGjBnjnQZRKBSfRc3gAqmSqChXDlW2K5VEOfmCqUpcZM86RSI0NBR16tSBxWIpeOfNq4FrF4FHhkuyln2/ANXrAgNGeL6hbkLxdrm0YkAJSOgcKN144vwrq5FFwS8MdAqFQnEVxT7nWNsLrLNKogDAqhKXwEsZVlxYlnUtD7rFDGRnAhwrBYxmZwKmHMCVz/oIhBDodDoEBQVR46yUQudA6cbXzn/RzHoKhULxURRPOcsqATmszXZFyqIY5oqhzlMPetFRHm4YBlC8RfSBh0KhUIoMNdApFEpAIagGurS82HvwJBBwVg+6KnGx96BTDXqRUdLmMIw1cws10CkUCqXIUAOdQqEEFIqtyLEMRFHEvcTLAIhquCuGuE4NEqUa9GKjetBZTWpFaqBTKBRKUaEGOoVCCSi0HnRBEPDXgc1gIKo2pCJlUSUuLM3iUmwI9aBTKBSKO6EGOoVCCSgUDzrL2AeJ2mdxscuDDmqgFxmtBl0Zd5GOJ4VCoRQVaqBTKJSAQgkG5Vjn2wU1D7ptkCj1oBcDZwY69aBTKBRKkaEGOoVSChAEArOldBiggmqgM2BZFlVrNATAqA5da5pFnfxX0aCXjvHxCIoxzrKaLC50PCkUCqWoUAOdQikFvPdFAl6efxm8EPheTVXiwjLgOA7tOj0MAtYhSJQTBODSGfUiGEgG+p7jqbh6K8d7X6j1oEPxoHvv6ykUCiXQoAY6hRLgEEJw4d9sPEi3IC2TL+nmeByB2AaJHvxTChJVDHde0aCfPwWsXg4u5YH8ucAw0G8kmfDpD7ewctMd732p0yDRwBhPCoVCKQmogU6hBDg5JhGC7DnPNQW+0STI2RKVNIs3rl8AQNRKoaoHPVUyzFm5lH2geNDvppgBABlZXkwbqXrLGYClGnS3QseRQimVUAOdQglw0jWGWq45MIzQ/LCvJKqgPKSoGvTMTOmvbP8IAZIHPSVdWiXxasyBjQedVhJ1G1fOAwveBi6fK+mWUCgUL0MNdAolwEnPsspaSoMHXdRIXGy3S39ViUtmBgBAp2jTA0Q0/SBdWhHINXuxP8rgsjTNolvZ+C2QlQF892lJt4RCoXgZaqBTKAFORrbGg14KMrloJS4cx6FXv8dBwKqedUXKwmakS39lQzJQKomWrAedVhJ1K3p9SbeAQqGUENRAp1ACnHRNYKipNEhcNB50hmFQtVotAICgTbNICHS87Em3y4/u76RkSOdbEIn3svaoWVxYKnFxJ2XKlXQLKBRKCUENdAolwLHxoJcGiYvcRY5lwPM8vlg+V87iovGgExGcvD9r51n3d1JkiQvgzQcyxUAHLVTkTsLKWP8tBMYKD4VCcQ1qoFMoAY42m0dOKfCgK8GgnF2QqFWDzgMiASu/5mTXeqB50AHA5C2Zi40HXdGgUwO92GgfctJSSq4dFArF61ADnUIJcNJokCgAbRYXxYMuGZKcqkH3/7ERBILUjBKQNGkLFdE86O6Dt66GIOVeybWDQqF4HWqgUygBjo3EpTR40DWVRAHAYAgCIBVsAmQDXRTV9IqBZKDbF6IyWbzkxRadGOiU4mMxW//9ILnk2kGhULwONdAplABHK3EpDR50QbRKXPR6PSa8NBUEnF2QqAgdkT3oqsTF/zW+D9LtDHSvedCdVBKlaRaLj0XjQX9APegUSmmCGugUSoCjzYPuNU1yCaK1FUVRxMULpwFYq6kKoiBp0OX9WdlAD4Q86CkZFpvX3teg00JFbsVG4kI96BRKaYIa6BRKgFOaPeiCIGDrlk1gQFQVhqpBdwgSDTwPutlbxYq0QaKK+D8AJEMljtZApxIXCqVUQQ10CiWAEQSCrNzSpkGXDXTO+XZRyYOuSlwEebv/j02KnYHutfOtGOjaSqLUgV58tBr0lGS6KkGhlCKogU6hBDDaAFEAyCkFHnRF+szaBSsqedAFUTLQWY4DOE5NtxgIBvoDOQc6I/fda9VEtZVE7bdRio5Wg85bANH/V3koFIprUAOdQglgMrJLyKNaglglLgDLsmjeoiUABqIoGeeEEDAAWFYH6AyS1IWQgMiDni7LmcqF6wB404Mu/6UadPfC28YU0MBbCqX0QA10CiWAUQy2smGywVYqPOiKxIUBx3Ho/8gjIGAhEqLqzDkwklZab5AripKA8KArfQ8LkXpl9laaRe3YsTQPuttQPOg66fdLq4lSKKUHaqBTKAGMYqBHR+gBlI4sLtaU3Ax4nse6dWvBQBoHixwQyhEALAfo9eAIA5DAqCSqpJIMDZYu7d7zoGskLrSSqHsQeGlcGRbQGaRt1INOoZQaqIFOoQQwGXKKxehy0g2+NHjQlXSKHCsVJ7p48SI4TjIaeVnDyxGNB50AAAmILC6KBz0kSLq0e0+Drg0SVW4r1EAvFor3XK+3RjwLfN77UyiUgIIa6BRKAGPmJSOpjFG6weeaRdWIC1SU7nGsNUhU+aeZ5wHIOdBlA50FABIYedAF1UCXzrfXVkxETZpFNYuL/49niaJkcNHprakrqQedQik1UAOdQglgFGNcr2Ng0MleVT6wDSfFSGU1VzdO/rdFEAAiS1w4jcQFREq/6OcoEmVF4mLyVh50qLoiaqC7C17jQWdlDzrN4kKhlBqogU6hBDBqykGWQbAsewh0mYuoSlykINHRo0eDkQ0cXh4QDrIUQ5G4EEAMAINS6UNosJc96MSZgR7Y88zjqAa6gXrQKZRSCDXQKZQARvUmM0CwwcuBgyWEoMihWQYMw6BixYpqTnSLrOHVqR50A1hIHvRA0KAr+nurB70kDHSaZtEtqBlctBp0/5+jFArFNfzCQE9JScHMmTPRtWtX9OjRA7Nnz0ZWVpbNPlu3bkXfvn3RqlUrTJw4EQ8ePCih1lIovoOoMVZVD3qAG+ii5qGE53nMmTMHHCP12SwIAIgmSFQfUHnQlfOtBIl6TeKiZnFhAEX6H+CxDh6H1xjoqsTF/+cohUJxDb8w0IcMGQKGYTBr1ixMmTIF3377LUaPHq2+/8cff2Dw4MF4+OGHMX/+fJw7dw79+/cHoR4cSilH1Oixg/SlQ+KipBpUMrcAVoWAIHsgpSBRTipUJO8TCHnQrR70kpK4sNSD7i6UIFEbDTrN4kKhlBZ0Jd0AV9i6dSuCgoLU14IgYMiQIeB5HjqdDvPnz8fw4cPx8ssvAwAaNGiASpUqYe/evejcuXNJNZtCKXHUoj2l0YOuzeLCSjIWJUhUR6DxoDMACYxCRWoWF29LXNQsLrBq0EEkI51h8voUJT8sGg262ST9W/D/OUqhUFzDLwx0rXEOAOfPn0fFihWhk6urHT58GHPnzlXfj42NRb169XD48GEHA91isYDnrV6InJwcAFK+ZOpxL50o5z4Qz79isDEMEGyQDKUckxCQfVXQ6u4JIQgLCwPLawx0ACxhQBhNmkVIhYr8fVwU+y1EjjcwWbzUJ/U7GM1fIkkyWL9YqPW964CzNIuCQFcmPIjPzQGKV/HW+Xf1+CVmoH/22WdYtGhRnu/369cP8+bNc9h+8uRJzJ49GytWrFC3PXjwAFFRUTb7RUZGOtWhz549GzNnznTYnpSUhNDQ0MJ0gRIgEEKQmpoKQKo+GUikp2dCEERkZWZAFHgIgoikuylISsop6aZ5jLQ0uc9ZGXjwQMDIkSPx7qoHEAQR9x7cgygKYAlgslhgzs0FIxAQUUSuKRdJSUl+PQdMJjMEQUROVoo0BtlmJCUlefZLCUG0/OBz7+5dgGEQTURAJLiXlGiVZ/g4vnYdCL6fjHBBRK7FAs7CQy+ISE2+B0twWEk3LWDxtTlA8S7eOv+KY7ggSsxAHzx4MDp06JDn++XKlXPYdvLkSfTu3RuzZs3C8OHD1e3BwcEOQaNZWVkIDg52OMbbb7+NadOmqa9zcnIQGRmJ2NhYaqCXUpSn2djY2IC7KIeGEnCcCeXKlkGuYAbHWRAUEo7Y2PIl3TSPERoKtc/R0RE4ceIEgg3h4DiCsDJlwbIsdGAQFGpEUPlI6BgWDMOA03N+PwdYLg0cx6NypWhwXDoEwiI2NtazXyqKcqJ5BrFxcdI2TgcwAmJjYqR/+wE+dx34NxTgWISWKQvwZoBjUb5cOcDT57MU43NzgOJVvHX+PWqgp6Sk4PTp00hJSUF4eDjq1q2LSpUqFeoY0dHRiI6Odnn/w4cP4+GHH8acOXPw/PPP27zXoEEDnD17Vn1tNptx5coVNGjQwOE4er0eer3eYTvDMPQHWYpRzn+gzQE1iwvHaKpLkoDrpxZtJVFRFPHLL7+ADR8GAOBlTy8HgJEriXKApEEH8fs5oCT5UIJEzRYRhNjq8T2GNge6tliRH42nT10HtHnQlYccUfCr8fRHfGoOULyON86/q8d2WRyYk5ODTz/9FK1atUJkZCS6d++OZ599Fv369UPlypVRt25dvP/++7h3716RG50Xe/bsQd++ffHJJ584GOcAMHLkSKxatQq3bt0CAHzyySfgOA79+vVze1soFH9CMdg4lkGQoXRkcVEDYzVZXDjZQOVF+0qihgCrJCpXjuVY6OXKsRaPV45VngI1Nx1aTbT4ONOg0zSLFEqpwSUD/dChQ6hfvz5+/fVXvPzyy7h06RIsFguSk5ORm5uLO3fuYO7cuTh//jyaNGmC1atXu7WRo0aNgsViwYcffohGjRqp/ynaypdeegm9evVCrVq1UKFCBSxYsADr1q1DeHi4W9tBofgbzgoVeS2zRwmh7bOCYt9YRCkPOktkb69eLy0jkgBJs0g0aTXloGCPZ+1xCBCFdcCpgV50VA+6Ns2i/z9EUigU13BJ4hIUFIQdO3agbt26Tt+Pi4vD4MGDMXjwYNy7dw+nT592ayN///13WJSUUxoiIyMBADqdDl9++SXmz5+PlJQUVK9eXc3wQqGUZrSFivTyT8LM+78hmh+Kk5FlGbAsi3bt2uGPSxwAXvKgQ5K4gNNJWVwIIFUS9f9xUew3jmUQpGeRCQFmT+dCFzVFihSoB734aNMs0kqiFEqpwyUrtnnz5i4fMDo6Gt26dStyg5xRr149l/aLjIxUjXYKhWINeuFYq60U6KvkoqbPHMehT58++PPKNQAAL+chtFYSNYADAxAEhIGueNA5joFBr6Ra9LCRrBYp0uoqqYFebGwqiVKJC4VS2nBbgtqsrCzcvHlTTVFDoVBKHkWTzLKMqsMWArwEu7bPPM/j66+/BsdKnkdVgy7tAOj1qgc9ICQuglbSJJ1vj0uaiLpMY93GUgO92GgNdI5KXCiU0obbDPRvvvkGVapUwRtvvOGuQ1IolGKiyj00CTYC3QmnDYwlhODatWuq7ciLPAAiVxKVgkR1hAkIDbqoefBiWa0HvQQ06KrExb/HtERRgkT1BoChHnQKpbThNqH2oEGD0KhRI1SoUMFdh6RQKMVETTnIMeq/xQD3amoDJRUUhy4vGzisInHR6SVvOggE+Ld3UnuuAS8GBasedK2BTg3KYmPRBIlSDTqFUupwm4EeFxeHOKVIBYVC8QkUOQvDMFItGQS+zSRoAiUVWEaR90hv6gDVg84SyB50/35wUeQtnNxX1YNu9rQGPZ8gUUrR0eZBp1lcKJRSh9skLhQKxfdQZA8sq40z829DtCBEjQddp9Nh7Nix4ORCLzyx86ArQaIgEPw8D7qaXlK25XSyJ93jDx5qkKjmdkKzuBQfp3nQ/XuOUigU1ymygf7ZZ5+hSZMmKF++PMqVK6f+N2XKFHe2j0KhFANtVU2rF7kEG+QFtGkWAaBcuXK2GnRCpEJFioFOIFUS9XNjUtXey+dZ6bPiWfcYzrK4KMY61aAXHacSFzqeFEppoUgSl6NHj2Lq1KlYuHAh6tWrZ1O2lGrQKRTfQdQU7VGdcH5uiBaEtVCRlMVl/vz5CK3xtPyenGYRkIwelgUn+yn8vZKoYFdB1Zq1x8NfnF+QaICv1ngUmzSLVOJCoZQ2imSgnzlzBgMGDMDYsWPd3R4KheJGBG3RHtlWCnSnpqgaqtZtqrEqG+FqHnQAnPw3UCQuSqyB1yRNRJ1k1m1U4lJ8LDQPOoVSmimSxKVRo0a4cuWKu9tCoVDcjLZQkWK4BXoedHupB6DJ4iJoKonKXkmWkf76e5pFwU7a4zUPuuhM4qL8O7DnmkfhlTSLNIsLhVIaKZIHvVWrVmjXrh1GjRqFhx9+GAaDQX2vVq1ahao8SqFQPIdyP2cZRjVSAz1IVNAExjIMg4iICDCc1oNOrEGiALgAMdBFJYuLg4FeEhr0UpJ035NYnGRx8fM5SqFQXKdIBnpGRga2bt2Kmzdv4ujRozYa9OHDh1MDnULxEbQZTRSJS4Db51YPOsdAp9Ph5Zdfxqc/3AJgrSSqFioCwLKKBt2/jR/7/O/ey9qTj4FOJS5FgxA7Dboa8VtybaJQKF6lSAb6r7/+CoPBgKSkJBiNRne3iUKhuAltRhNWtN0WqGiDREVRxJEjR8CgsvSeYsQCGg06J78nghBi43DwJ+zzv7PeDhLVjptiUFIDvWiIojR2DCPJW+Q0oTRIlEIpPRRJg24wGNC0aVNqnFMoPo5W7sF5Ky92CaPtsyAI2L59O1hGslJ5kQcA6DQSF4bhwMq50EX479OLmEcWF88HiebnQfff8SxR1MBbWdpCPegUSqmjSAb6Qw89hCNHjiAxMdHd7aFQKG5E1HiT2VISJKrYi9pKoo5ZXGA1fjhWzoVuTcPojwialJqAFyUuypjZrDwoBrpnvzpgUYNHFL0STbNIoZQ2iiRxOXLkCEwmE+rWrYtmzZrZBIk++uijmDRpktsaSKFQio62UJHiOfdjG9QllMI8rMZAV+rmSB50AgNhrJkxWA5KRkZ/TrVYcnnQFQPdWZrFAJ9snkK086BzNM0ihVLaKJKBXq1aNUyePNnpe40bNy5OeygUihsRNXIPVvSS5KGE0eYDZ1kWnTp1wo0sycCRKonaSlzAsFJedPh3oKhq09lVEvW8xEX+SyuJug9RDSiQ/rI0zSKFUtookoF+/PhxXL9+HR9//LGbm0OhUNyJNje26oQLbPtc7R/LMuA4Dt27d8e3W5MAADxRNOiwGpEcq2r9AsODLr32XppFJxIXNadngE82T2HvQaeFiiiUUkeRNOhVq1bFv//+6+62UCgUN2PjQfda2r2SxZoPHOB5HitXrgRkw1wy0An0WokLI2vQQfxbg24n7fGexEUJEtVKXGgWl2IhUg06hVLaKXKQaGJiIr7//nuYzWZ3t4niBQSBIOl+6Tt3R8+mY+WmO34VKMmLPLZe343/HpiHL8+sK9Rn1YBJhvFe2r0SxprFhQEhBLdu3VJlH4qHXAdG451UsrhIqRb9FWsFVemv+kDmaSNZOT6rlbiob3r2uwMVgXrQKZTSTpEM9G+++QZHjx7F0KFDERISguDgYPW/iRMnuruNFA/w3bYkTJx/CRcSst1/8K0/AL//7P7juoHvd97Db4ce4OqtnJJuistsvroTK/75FqeSz2PTld9ACmFwCaXRg65KXKzb1Aw2RNKg64lmozaLS0BIXOw86J7uktM0i973oAsiwY7DKUh6EACOBzXNojJHZTWqwJdMeygUitcpkgZ94MCBaNasmdP3YmJiitMeipe4edcEALh1z4R61ULdd2CLGTjyh/TvLv2kKng+REa2ZK3k5PqPJyrNlG7zWiACdIxrP11R401WChUFuurAGiQq5Ta3/hvgiVSdUS8GcJAo6+0gUSca9BKoJHriYiY+33gbDzUpi0lPVvba93oEhzSLeXvQLbyIv85nonFtI0KDOYf3KRSvkJ4qzc9y5Uu6JQFDkQz06OhoREdHu7stFC+SmeMhQ9Wi8V6lpQCRvvXAphroJv8xxCyirdfMLFigY1000DXeZCVI1J/kPUVBa6jqdBwmTJiA/We0EhciXfjUFHZKmkUSGB501abzVpComsbFuk0x0L0oyUhMlq496dn+ew5VHNIs5p3F5dutd7H1wP3AeDApBGevZWH9znsYN7gCKkQFlXRzvIYgEmRmCygbViTzzTMQAqycL63wvPqB7fIlpcgUeRTT0tLwxhtv4KGHHkLr1q3x/PPP08BRPyIrR7oBZLvbULVYrP9Ove/eYxcTs0WE2SL1158MdN7OQC+MESnYFCoqHWkW1Yqaso1oMBhUe1GQg0WlIFGrd5KTh0Tw4yA825UDbSVRD38xcaIpKgEPenKqdO1RfuN+jRokaqdBd7LCs/WAdJ3d/0+aN1rmM7z72XWcvZqFb7feLemmeJWP19zEc7Mv4N/E3JJuipXcbCAjDcjOsnXSuZE7ySacupzpkWP7KkUy0HmeR8+ePbFt2zY8+uijePLJJ5GQkIA2bdogOTnZ3W2keIAs2YOe63YDXfPjTH3g3mMXE2XVAAByzf5zE7cIZmlcc7IAU66DRz0/1MBBlrE6NQPbPlfj6ziOAc/z+OSTT8Ay0kZea6AzVomLEiQaSBIXzltBos4qiZaAgX4voAx09Ycr/XUhD3pYaGmVtwT4Bc2Ow6clyePRsxkl3BIN6anWf5tNbj88IQSTFlzGe18k4G4gxJi4SJHWSPbt24eMjAycPHkSQUHS0tKUKVMwaNAgfPfdd7SSqI9DCEFWrnShz851s8eQ910PeqZm6TvH3f32IPydf4FcJaiVlwx2F1GMM0ni4iWPagmj1d0TOztHJIJcqAiahOEcOHna+nMWlzwlLoKXJC4lHCSqeNBNlgAw2BQPupqrv2ADvXwZ34r38SS8Zk7Hljfks2dg8SDNen+NifCh852hWb3RrqK7iX8TrUZ/RraAmFIicy+SB/3GjRto2bKlapwrPPTQQ7hx44ZbGkbxHGYLUW/abpd6+IkH3Z8kLhaL7VImzxfCQFdjzRjvFa4pYayyHus2RkmzCE0edMUryTCBncXFW1PdqQfde78zVeLiR6tjeaIY4ppc/QAcxlNrqJYL9yFNsodJ1KQIZrU/dFdJuQ/s2CjFSfkRl25Ys4/xnn7wLgzpWgPd/R5u7WpBoN+/tBTJQK9fvz727NmDe/fuqdssFgs2bdqE+vXru61xFM+Q5UlD1Yc16DYedD8y0O016BaL60uIArEaq1aJS+Be4LT6epZlwDAMYmJirMaqVuKiKQLDggEDP/egKw9jjA9kcWG960E3W0SkZ0nn1swHwPy21/Xn4UFXHkoAgJQiw+VGkvUaWGhJU0YasOhd4MDvwF8H3NouT3PxX6uB7lMrRRmp1n97wEA/ds5qoFt8qd8epkiP3K1bt0b79u1Rv3599OvXD0FBQdi9ezfCw8Px1FNPubuNFDeTpZF3uF3iYuNB9y3vhL9q0Hk7o9Heo54fRKNBF1jpwhbIEhfFRlEMcp1OhwkTJmDXUWkuihDAApLHXGP8WCuJBoIHXXrtNQ+6qkFnseXa7wCAR7ysQb+vWfo3BYQG3T5IVKkkats3rSc5IB5MXORGkvUaaC6swfb9Kuu/s/wr6PDiv9a6JRZfOt9aDbqbDfT7aRabuiWlaZ4XOYvL999/j8WLF6NMmTJgGAZTpkzB4cOHHWQvFN9DyeACeNiDnplmq0kvYTKy/NODbiG2HnRXJS6EkDw06IF7gdPqzwFAEATs3bsXgHS+RUgadIPWg84w4AIiSNSasQeA9yRN8hzjGYIvTq/BqtNrwcO7Sfe1nmSTWSxUMS+fxD4PuhpEYfsAqTXQTX7kdCguWg+6hS9Ev0URuHHV+tqP0gHyAsHVW9YHk0L129NkeE7iYl9M0af67WGKLFpjGAYjRozAiBEj3NkeihfwqBbb/sfpQ7nQ/VWDzovW8vQ8iMsedK1dxjCMt1UHJYISW6HaM6KIXbt2ofMjDaT3iaRB1xHGWp1R9aD7uwZd+qto0L0ncZHjWVjlgZAghyEIB7ymQdca6IDkXTToi6BN9hWsKXnkv84lLqXXg66RuBSm3/YrZH5UmfXWXZONcVpaPOj2KyQ+pb33MEU20Pft24cVK1bg1q1bEDXLbgMGDMCUKVPc0jiKZ9Bq0D2axQWQdOi+YqBrNOhuTy/pQSyyNzJEZJDBElhc9qBLf1WDTckFHsAedOXabR84xrEMCIjkQYecxcWmkqjyef+ZF/aIdnnQWW9JXOSJlg2rsZPFCrKB7p25ds/OQDfzBAYfSnJRaES7INE8KonaGOiBIO1xAQsvqkWpgEJKXHg7g9yPDHR7p5JPGegezOJib5AXWtLkxxTJQL969Sp69+6Np556CoMGDQKrWSZq1KiR2xqn5eTJk/j555+RnZ2Ntm3bYuDAgWpmBkDKLPO///0PycnJaN++PYYOHWrzPsWK1kDPNUnLwW4bK/unZx/K5GLrQfcfTykve3UlAx3gBdcugPaSB63RKoqkaNkPfByrB922b9IQiAAIOECStDBqPkIpDzrxb4mLmr3GXhXhJQ96NmMduyz5QchbSfftPehmswiE+HFecNkQJ2BwJzMRcVy4pEe18wAn3S+ioerHZGQLNoHuhZO42F337Q12H8bRUPWRa5XAA9kaLb+bPej2/fapBxMPUyQD/eDBg+jZsydWrFjh7vY45ZNPPsG6devQt29fhIaGYtKkSVi3bh3WrFkDALhy5QratGmDHj16oEmTJpg2bRp27tyJzz//3Cvt8zeycq0/bEEk7l0OtvegZ6a757huwG896KqBzgIQXM7iohirWpklyzAQCYFIihGA4sMoF2+dTnkoYdG9e3fodCzACCAAOCLPdW0e9IAIEpX+2nvQvVVJNJuxjl0Woxg+JWOg+32gqDwPNzM3sWrX2xhe+xEMBxxOpjY41lxKtLn289lkLh0edPt6Bj5jqGbY3eMLkWXMFRz7XTrmOVBEAz0uLg56vffWDwcOHGhT/Kh79+7o2LEjFi1ahOjoaLz//vto2bIl1q9fDwB49NFH0axZM0yePBnx8fFea6e/oPWgA0B2rgiD3k3mmvL0zHGSXtKHUobYpFn0o4AqXiNxAeByoSL7jCaA7DQWZK8qF3gedMXbopcNdI7j0KlTJxw7mwHCSudfrxjoGomLMvsDQeJi9aB7K0hUGjNbA13+t5ckLmmZttc0n0pBVxTk6+Y6chmAHmsvb8FwhDp4gC0a46W0pJ8rlsFmb5DnU/jJ1+BFXzXQU21fe1ji4jP99gJFMtA7deqEd999F7/++iv69OkDjvPsUmL16tVtXqekpMBoNCI0NBQAsGvXLrzxxhvq+02bNkWNGjWwe/duBwPdYrGA1zxF5+RI6XsIIf4f+e8ijga6gLJhbjqHyo/TECyVphcEn4lKzMh2lPYA1nPvq+dfSbMYQiTLi+fNLrVVkG/yDAN1f45lIAgEvECg1/lmf4uD2SIb4RwDQgh4nsfKlSvRstMwEEbK4KIXZb8uw0pzk2Vlr7rkQffVeVAQvEbeQwgBy0ivBdHDc1s+tiprAZBFeGmMRdErv39eXj4IDeaQnSvAZC78efSp64BsOEYyIciStf1E2S6KACOdY62xKq2GitAF4IO3Ft4uqMJsKcQ5s/egWyw289On5oAdvJ1harb4SLaitFTb12azW3/z9g9gZt5z/fbW+Xf1+EUy0L/++mscOnQIjzzyCHQ6nY2B/txzz2Hx4sUFHmPr1q3YtGlTnu+3bt0aY8aMUV9fuXIF8+bNw4MHD3Dq1CmsX78eRqMRAHDnzh1UqFDB5vMVK1bE7du3HY47e/ZszJw502F7UlKSavAHOskPMiFoLnI3b98FK7hnRSQsNQUhggiB5cAJIrIz0pGVlOSWYxeXtEyzekMTBODW7UToZEMuNTUVAHwybsEsS1yCiPQ7S01PRZILY5qeJUIQRIgi1P2JKEAQCBKTkhAaFHgil8Qki9RnwYKkpCTwPI+7d+8iLS0VgmgBIQQcAURBRHJyMkhQJozZ2WBlI/ZB6gMkGXxjvhaW9HTpd52VlYGkJAEpKdJY5OSYXJovRSXowQOUEUSkWrIhGqTrygM+G6IgIiMlBble+P2bTFJfdSwgCCISk+6jbFBGwR/U4EvXgZDUFIQJIsJFHURRWjETRenJ8l5iIsCyEEUCQRDBMIBBz8BkJrh5KxEhAfi71pKUzEMQRBj0DMwWguxCzG/ufhLKa+59luwspGo+60tzwJ7k+7kQBFFdnE7PyPbo79pVQm7dQJggSlkIRIKc1BRkurFdaWlZNv1OSclAUpJnVjq9df4Vx3BBFMlAHzhwIJo1a+b0vZgY1zJ2xMbG5nkMAKhWrZrNa6PRiGbNmuHBgwc4f/48Vq1apXrvWZaFYLdUxfO8U8/+22+/jWnTpqmvc3JyEBkZidjY2FJjoIvIAcfxYGQvTIgxArGxRvccPMiAreVzYCgTgh5ZLMJCQhAWG+ueYxcDs0WEIN6HQc8i2MAiK1dAeNkolDHq1KfZ2NhYn7soA4DAEIAAoZwBQBaCgvWIdWFMDekWcFwKggw6dX+9PhUWQUB0VAzCQv04iC4P0kzZ4Lh0GI1BiI2NhUVe0YkqHwFWdwtgGOgJA5ZjERMXBxiCgDJlwCWyYBiCsDLhLo2tLxISSsBxJpQrWwaxsZHIEXLBcenQ6Qye7VPSvwDHgjfo1IQBvIEFy7EoW7YMynphPFkuHRxHUCYsCOnZJhjDyiE2NrxQx/Cp68D1MIBjEaELActKaVUteh2CBBGx0VGATg+zRQTHPQDHMggJ5sALPMpFRKNceJGTs/kF2UIuOC4N4aE6pGbyIIzO9fktmKzR0wCCdJzNZ31qDtgRficNHJeF8FAOGdkCOH2Qb1yrDHppTMPKAJnpMBp0MLqxXcEhd8FxuTCGcMjKERAUbPRYv711/j1qoEdHRyM6OrooH1Vp0aIFWrRo4fL+cXFxGD9+PABg4sSJiI6OxtatW9G/f39Uq1YN169fV/clhODff/91MPIBQK/XO9XPMwzjcz9IT6EEiUaE6/Ag3YJcs+i2vpstufgsOh3gstEVUdDJy7EljdLnsFAOeo5BVq6AXDNB2TCpbcr598U5oKRZDGUNAABe4F1qp0iU9IrWfqnZ2ojveYjcgbKCredYm/PJsQyIHLhoIJDKEul00txk5SBRQiAS9/0WvI0S7sFxUr+V9JqiO7M0OUUJEtWkWYQgjTGBV37/yspYSJD00Gnmi9Znn7kOyCdT0DTjbpCIqtlQJS5qjAnHIEjHIAOSPrfE2+5hlJiK4CAWyJQkLi73WdHw63TSxYLnHeanz8wBO7RzPCNb8J1zrcTtBIdISSEsFrf+5pXzHRosGei84Nl+e+P8u3psl9bCDh06hL/++sulAyYkJGDLli0u7esqO3bssHl9584dWCwWREREAJCCQr/99luYzdJS4NatW5GcnIy+ffu6tR2BgqJBj46QHlSyc923XGTi5QhuhsF9neCY1qqEUAJEw0I46cIO/8jkQgiBrOZFMCcZ6GYXg0Tt0+4BXgwcLCGUoDkli4tOp8OkSZOgN+gBOQ2gTjntmjSLiqfCn9MsqgY6a19J1NNfLBcq0mrQlZzoXhpPpY+hwdI59fuUg/LJNGtSVyYaiM17Sp91HAO9HORfGooVKYvlocHKw1gh5pjyBG8Ilg/mP1lceLnfyv3LZ4IllXt8UIj0181pFpV+KtKt0jDHFVwy0A0GA5588kl07twZn376KU6ePInsbKn8qslkwsWLF/HNN99g4MCB6NChg2oou4uff/4ZzZo1w9NPP43BgwejVatWeP7559GhQwcAwFtvvQWe59GyZUs88cQTGD58OObMmYPKlSu7tR2BQpZcnCiqnGSgu7OqpkmpcskASXrfyeKi5EAPC+VUL5s/VBNVKltyYKCXDXRBdO2mohYq0mRxUf7pC7FFnkAJpFKyuACA2WwGy0IOEiVyFhfGpkojK682+HclUdsqqqoH3eMPY04KFUEOFvfSRNN62YBASLMoG+iw9uOOQR5f2ULV5vxX0uT6TG5sD6L0O0h+KBEE4rrDQTUm/c9AV/oY4nMGujzngoKkv27O4qKumBiUJAmBP8cVXJK4tGjRAmfOnMH69euxatUqTJkyBSaTCRzHQRAEsCyLFi1a4Omnn8a3336L8PDCaf8KYvHixbh06RKOHDmCkJAQLFy4EDVq1FDfL1++PI4dO4bffvsN9+/fx8yZM9GwYUO3tiFQEASCXJO0jB9ZVjbQ3VhN1MybpVnFMLin8x0DXVklMAZzqpfVHwx0i8jLRiVg0BsAC2ApbKEibR501ltGW8mgeNMUA53neSxbtgzDnn4FYKWbsZ7ARocKloWixg8MA12Rbdlu9xhqJVFnHnTvGuiKd9HsR2lUnSIbkmbNmCbqBQB6dVVCPd8cYNAFyMqBC9j328yL4HkCzuCCbED1oMvGJO8/v3erxEU51z4yx1UDXfGguzcPupKdSlkd85kHEy/gsgZdp9NhxIgRGDFihOo1T0lJQVhYGGrXro0yZcp4sp2oU6cO6tSpk+f7QUFBePTRRz3ahkAgW66gGRrEqhM+250edEH5cTK4qxd8xkOhlXuEyDczf6gmysvech1hoNPJBrromoGu9lmjd/Na8ZoSQrmY6+wqiUoedKnTHJF059o3WSXNYgBIXFhvS1xIXh50vdcMdMUxGhooy+DyyTRpDPQ7urw96EGG0uNBV3/jHAO9joGZlx7MgwwuCAIUfYxioLvo7PAFeLs4C58xVFUDXV6V8FAe9OBA+W0XgiIFiQYFBaFx48bubgvFC2TlyJ7kUE5dDnanJ9ms0aDf1ftODnSt8aJ4IHL9wMtmERWvLwOdTrqp8C5KXOwNNsAqcRF85Ly4G1XiYlcZl2MZQC6eYyCwW1bgrB50P35ysRps0mulix7PlSyPmY2BTnhovb2eRpnPIbLTweQHv+18kZ84TJrxS9JZbN5TK8dyjFporjR50FlZ2pOVW4giTYrDSJW4+L6TRsHBUPWVc608HQd7RoOu9ttQ+jzogZ0wleKAcuMK0rNWQ9WtHnT5JsIwuKvzHQ+6YqSwrPWH7hcSF0EqpKEjgF4v3VQsrhromj4rBLoHXfGuKMVaGIZBpUqVwLKslMWFSKsRdoMiZ3Hx7yBRxUhVtOeqB93TNojqQbd6zrKI9zTo2oI9incxUCqJaiUudzkLRBBrkKjmgUzVoJcCfa6iSilScKzg/xr0UFWD7iPn2sGD7l4DXVAlLsrKgY/02wtQA72UoVzGWMaqZct2pwZdtP447/pQkKjqTWYYjzyYeAqBl8ZTBwZ6TooZsLh4U1HuRdogUcW7GqgadOVirtdkcRk7diyCDDopSBQEOjhKXDg5SNRV+ZAvopxvRdKkGOre06BrKjSDl7IPecFAV7rHMAyCA0XqIThq0AX5P8Wo1FaOVTTofr9y4AI2wbHy79zlfivXTr1BOZjP3KMKwl6D7jOeZHsD3c1JQpQHMqXf9hVVAxlqoJcyFMOM0Rjobs3iIlo96Pd1Angf0fjZaNA90G9PYZGz4ugJCx0rGeg8KaQHXaP2UD3oAXqNs6gGupLhQcCuXbtAiKhKXPQiHCQuBtVA9x+Pmj2i6kGXXivn3eMPY4SAgCBbnpcGOdtQDku8InHRBkNbpR6+/9vOF3nczNqgZUYuWiYbROr51mZxKQXGi3It13HW8+2ysao8xer11h+Kj6QCLgjFUFW09oJoXTkqUewz4/BuNtBljzlNs0gJeBSHlqTFdrMGXRStNxSGgQjgvpjrnmMXE1ETMBkiL5X5hQZd8aAzrOpBd4cGPVA96BY7iYsoiti7dy8YiCCsNDededCVFNOu5pj3RUouSFSEmQEEEOhZHcoFSQkDsljRumTnQbRBg0rqPb+XuAgCCAjM8kNPsBx/IjBQjUzVg17aNOiafisrZS5LexQPOsvBpJOvAbx/PJTbnG/ZAWHxCQNdHnu9QfL8CYJbdXX2HnQqcSmA69ev48qVKwCA3NxcLFy4ENOmTcM///zj1sZR3I81s4c12MRt2Ux4C0wssakilsS4VtLW01gfTKwadH+SuOjBQq+TCxW5mAowPw16oBYq4u3SLCpwnDVIVO9Eg26Qs7j4swfdPs2itpKoRyEE2axc7VYfAqNeChbL4rwkcdEUaAqYfOCiAAsjPd/oWA46VsrnwGs86FoJmyL18Pt+u4CNtEfxoLscJCoN2jrLBYyoegP7wnL8xkC3rhxYH0x8wli1ljC2Sod4962c+2z2Gi9Q6Cwuo0ePxtdffw0AGDduHHiex/bt2xEWFoZPP/0UFy9eRIUKFdzeUIp7YRhGo0d200EtZpgZ2x/PPeIbBrriRdRq0P0hzaJZlrjowILjpJ+rq7m6FU+TjQddzezhxkb6EBbB1oOuwDB2hYrsDXRR1rL6tQfdLouLkrHH0142QiQ5C4BQXQiM+lAAsgfdC/perXxN9aCb/XyCi6J8LWVg4AzQMRwARtKgq1lcrJImRfZQGgx0Z4ZqYTzo28tkY43pDMAAZ0LM6OgngaKK9porSvYaTyLPxz8yLsBSNhc97zGA2WSVvBQT+xoHpclAL5QH/a+//sLPP/+MP//8E6dPn8bBgwdx/PhxXL58GefOnUP37t2xdu1aT7WV4gasy+CSkQ640VjjLTAxigddOvYDuLdoQVHRepMNfrQMrmj4dQwLAyctc1tc1EyqlUS1GnQmsLO4KDcs5cbNcRz69OkDvU6netB1hLHqTwGA5SSjnQRIkKhsmWsfzDwqaSJEMsYBhOhCYNSFAgyQ5SUNulbiYjAU0mDzVRQDnQEMrB4cy8kadFg96BpD1epB9/1rWnFRJA+cRtLkqtFGeB7/i8qAcn/SEcZvMrlotfdKjI1P6LFFETwIFt/ejmUR96TgcDfmQud9NTjWCxTKg37mzBk8/PDD6NSpEwBg1KhROHv2LILkEq/dunXD9evX3d5IivuwBg4yVj2yuyx0iwVm2ZPGMSwEALyPBOBotff+lMmEl6uy6cFBp5OzuMBFD7ozDTqrvOf7fS8KvF0WF5Zl0a5dO2RmC3IWF0BHADDOJC6uV2n1RewlLsq/BZFAJB4MOCKi6kE36hUPOoMsTvSqxIVlAiibiShKckEAQZxBlfILIKpBqc1mYk036Of9dgGbBxN94bK4CIJFlWMBDCwM8RuJi82DqN6HJC6CgDROBA+pLbksQZgbUy0qBnlpNNALdc3OyspCeHi4+jo8PFw1zgEgODgYubm+ERRIcY5yM2NYgHF3TmyLWfWgh8jeXl+pzKhc1BlYJfL+YKNaBGuQqFqoyFWJi6aghwKnnnM/6HwRsA8S5XkeixYtgijyqoFucPCgs9DLw2HyYw+6NpuJAuuN802I5C1ngBBdsEbi4h0NulXqwWikHn4+vwVBlQsaOAM4hgXA2HnQpV05lkGQvvR40LX5360SF9f6zSsZRhgGYCAZ6P7iQXcWHOsL55uIuK9TkkNAsgHcaKArv29tkKjHi6/5CIXWoKekpOD06dMAgNu3bzu8pvg2RJN6T5E+uG2yWyzqTSVUF4xMAIKL3l5Po81wYZV5+P6PnOcViQsHg2ygW1w00ImzIFE1i4v72uhLKAa6sgRMCEFKSoqsupLzoDto0DlrkGjAedABC+Sbu95DX6wGiTIw6kMRqpO0p9msdzzogkZ7r3pU/V2LTbQadOuJk4JEZQ26arCh1GZxKWyaRfu0vzwDv/OgSwa6D3mTRREPdNZVCRPrXgOd11zTOY6BIBAIoiT1CXQKbaCvX78e69evd9imMG7cuOK3iuIxVA+67EEA3OhJ1mRxCZFv0r7iQSfEehP3p0BJCy9JXAwMB05Js+hiw7VL/wrWPOh+0PkiwAvOs7joOUZKs0hkiYtdmsUgOUjU7McedG3pdwU1a48nTzchyOZkL5cuWNJLAxAZeMdA12QzCQoUQ1UQVImLgTVIUkEGkohAsNWga7PX+P2DiQto+60vZPYa2wdwxr886HIXfVHiInnQGY940LXSHr1soJstInRc4FvohTLQn3rqKfTv3z/ffcLCworVIIpnUYxxlrEabm67h6pZXBiEcr5loKv9Zhm/Knev5DznGA56vexBd1mDbpvVA9CmWXRjI30IxaPE2WVxsUmzKDpmcdHLGnT/zoPu7HxLfz2ayYUQZCsadF0IWFk5KcrveRrRqcTFzye4KOWWBwMYOL1aodmpB11TSdTi7/12AVtDtagedP+TuKiGKsv4VpAoEXFfp3r+3O9B1xroOha5ZtE3Vg68QKEMdKPRCKPR6Km2ULyAVfbAqDdvdwaJmuTMAyF62UD3RqUSF9BWULVq0H2jbfmhaCb1rNZAd+0m7LRQkR8FyBYF5WKuZLXQ6XSYOnUqdDodWE6TxcWZxIX4dyXRvIJEte95BEIkQweAntNbs0MBXsnion0Q5VjJ8SCIBLxAHNJt+g2iVYMexBmQw+cCYKRVCaeFihQPemD+rrXY9Fve5uqKiWqgM9L/LH4kcXGmQfeJNIuCiAc6AZBTgUoedPetRGrTiVrzv/tAv72ASwb69u3bsWzZMpcO2LdvX4wfP75YjaJ4DuU+zWg86G7Ng84CAINQnVSsxGc86Bpj1Z8CJZW0f3pGB51cqIh38aHHaaGiQE+zqASJaiQuqampCA0NBcuJYCBLXDjNpU8OEmXg3x5051l73LxK5gwiqo+MLMNaV+bgnSBRbeEahpFSLeaa/HwZXBTVjFhSkKjUDx5QH3qsq4JaDXqA/rA1CBqPqrJa5LLERbTXoPuhB93nChUJeKAXAUipQE0skfKguwlrZi7Wt/rtBVzK4hIdHY1WrVrZ/Hfz5k2cPHkSNWrUQL169XDjxg0cPXoU1apV83SbKcVAGySqeJLdKXFRPeiKBt1Fb6+nUYxVjtF6kUuwQS6ieHw4loNertDIuzimaqEiRutRlf76w+pBUXCWxWXlypXgeR7gpCBRjsCm2q22kqg/a9BFTXYLBc4bEhdRlIxxQJa3yA+BXtKg268UqakW/dlY1RYqYvXQqXnQiYMHXSv18AnJg4fhNfO8sP0WVGNckbjAfzzovupJJrIHXcqRJtkAvHscHYQQp1l7fKLfXsAlD3qLFi3QokUL9fWVK1fw7bff4vTp06rkhRCCvn37SjdCis+iDRJ1ex503iwHNrEIlVOtCT5iCFrTS2qyuPhG0/JFMdANrB6czgAGkmxIEAU1GC8vrLnfrduYAPegWyUujr4HRs5/LFUStQ0SVSqJmgMui4t35ros4beuzDGM1zTo2rzYgFxVMwsw+3M1UVFQnR1BnAGsszSLNiXvCxcs6c9o57musEGiogWQi/QRPwsS5XkffSATRNznNGkWWfdJXLSpRBmGKXUGepFqVxw9ehStWrWy0aMzDIOePXti//79bmscxf0oN2opm4m8FO02iYtWgy5LXHzFg67kiGb8S4dtljXROpYDo9NJ+mniWi507cVNQVnxD9RCRc4kLgoMK2vQRThUEpXUk4BIRJ8prlVY8i1M5XEPugQDFox8W5EWJbynQVf6GhQIGU0EwUbiomMlX5pNkKgma4+hNOZB5zTBsS4abEqMSQgnywX9qFCRTdaeQj6YeJJsWNRCZVYNuns86Np4AwC+lV7SCxTJQI+NjcW+ffuQlpambhMEAVu3bkVcXJzbGkdxP4rEhWEYdZXfbV5uNQ86g1CD5EF3VY7haawPJloPuu//yAXZo6tjdYBOJ2cbIWp2l3w/66xwjR/lgC8Kql5RvqAzDIMaNWpI850VZA26YxYXBozqRbfXqfoL2iVwBW8FiVo16IxcVAcQQeCNGHFtmkUgQJbBiSgZOpCyuChjKgBqh20qaqpZPXzjeutJeM35LuzKgSBfN4O5IICRg0T9xYMuWJ0PvjTHH0DWm8v2hIklblui1cq4APhWekkvUOg86ADQpUsXxMfHo0GDBnjkkUdgMBiwa9cuMAyDZ5991t1tpLgRq8RF42lz129ctObuDdVLqys+I3FRH0ysVd79QeaheHz0rA7gdGrFS7NggbGAwjPWeANHj6qPnBa3w/O2edB1Oh2efvpp6U0lD7roKHEBJOmLCdLYKjEU/kT+ee89+MWESN5yhrGpr+D9LC6MzV+/XiUS5DSLYBCkCRIVGOJE4gJrekl/lvW4iLZybGENVYtsjIdywXgAJc2if6yYaVdEfSnN4gPYOjRMjBsNdLuYIuWvL/TbGxTJg86yLDZv3ox58+ZBp9PBZDLhxRdfxPHjx1GmTBl3t5HiRrSZPdxe8l4pT80w1jSLbvyxFgdnlUT9wUhVvLkcqwc4DhwYgBAILkhcnKZZZAI7D7rZTuIiCAK2b98OQRBA5EqiegKHNIsA1Fzo/u9BdwwK9nQedFETJMrKT8AE8Mpv337lwJ/qHOQJ0WRxYQ1SvAmjaNBtPegcK2UzYRgGIiGq1zFQsXpVNQ8mrqZZJLLERRdszYPO+8fvXXE++FoWl/usImeRYk9yPeBBt5e48KXEQC+SBx2QjPSRI0di5MiR7mwPxcOogYOaIFFCCAghagBhkY+tyd0bog+RbijSGyjis6DbEDVyD2u5e9//kQvyzVjP6aR83SIDcIDFhSh5Z4VrFCPGH+Q9RcFe4iKKIg4dOoTu3btLHnQR4JxIXADImVz8N9Wis8JU3vEmWyUuUnIM72Zx0QZLav/6twddgEnO/ZmnxEVjvDCMJPcwmf08vaQLiJoHk8JWElWkgSG6IAAMeAZ+6UFXpR4+EHPwgJEecII4A0y8xa0edMHueu5L0h5vULJWE8XraA1VrUHujvuokgHDwHDQMdKzn+AjS4g2GnRvlD93E0qQqJ7TAwwDHZQLc26Bn1X658yD7g8PJ0VB8azo9U4ubYysQRfhVOJiUORDflqsyNmKiVey9miCRDlNHnTvVRKV/ir9Vh9C/XmOq2kW4UTiYhckytou//v1g4kL2KSXLKTUwyKPXbAsYfOrLC42GnTfkbiY5cfzsgapiryZtc7R4mLvQVdjDnxg5cAbUAO9lGF/v3RnykElh7SB0YGTjR5tWrCSRHuztuqwS/7iVhC8msVFEpzroCzxue5B19hrfpUDvrCIInHqRVaQJC7IU+ISJAeJmgT3FdnwFqJIbGocKHglaw8hENU0i1aJi2S2e8GDbpdmUX0A9+c5rsbzMDBweilInJE9vnLWEcEu771iqAe6xEVwEiRqcdWDLksDlRVeC0NA3FiW3pPY5n/3HYmLAHlM5eKEJoa4LfbEWqSIetAppQCtJxmwBky6w1g1EWvObtWDDvc9TRcHUfU2+Vc1TeWGouckA10v/2Rd8aDnp0H3a+9iHmg9a4rnmOM49O/fHxzHgcg3ElZk7NIsykGi8nhZ/MSjpkX7u9aujHmlai4hqhku5cNhoBSC8WYedNbOUPVrT7KDB12RuFg9vvbeRY7zn+tacdD2u7CeZOV6GsQFgQUDAkDwEw269kHUl9INClASQ4QAkDXobno65u0eQnWc7/TbG1ADvZSh3KiVe7g7jVVF4hLE6mwLa/iExEW5iTPW3NB+cAO3yDcUnWyg65gieNBt5NZeyOpRQjjLgc6yLFq2bAmWZSFqg0QZm0EBADVDjj8GiVrPtW0ciVcCJomoBonaetDhlYlmn2bRn+oc5IkmnkcNEoW8Iikb6NprGuClgGAfoDgVNZUaB3qdATpZNsT7QXEy24qamiBRH9CgK/MwVB8qFSrSyLCKi/WhRJYhyv0uLUGi1EAvZSj3LOWibs3k4g4PuvSjNDDa0tTwCZeONThWU6DJD37jyg1FJxfWUD3ofMEyDOU+rS1U5E8PJ4VFuUnrNfoWi8WCBQsWwGKxgICXNOiCcw+6tZqofyx5a7GXOyhw3jjfkhIDkP8oqRYJ4N00i4onWZV6ePyrPYdozYilatAZRtKg84oHXdpVZ9fvQPxtaxE0K2VcIXX3FnkVTaczQC8/9LgScF/SqEXIGCmGyme02KIozUkoHnQ5D7qbfvcWuzSLalBwSffbS1ADvZShFiqSX7szL7aiQQ/i9KoXzXckLlZvk9J3f8hkoizJGnSygS57fSyWgg105xr0wF0Gt2iCqLRkZmZCJKKaa4QDbJcVGMVAl176Y5Cos4Bg7WtPe9ClWcqAZViw3s7iYhd34BVZj6cRCUxyfxyyuIh2WVzk/QJCe+8C2vSShQqMFUXwsuGoY/VSbQkAFtEPDHT7YElfkbgQUbrHMwxCZQ26mXGfxEXQpNQE4FMrB96AGuilDKsHXf7rxiBRk2Kgs3q1NLWveNCtRVz8K1BSkbhwsoGuSlxc8PI606ArKbL94eGksNgXKbJ5TxQABmAJI9Wgt0+zyDBWA92vPei2ffeOB13WoDNKhWIlDzrxThYXu777/SoRIbYSF86gXk+1pentVw5UYzXAJS7aWBNlurvUZ1GUxo9hoOd00MtxUv4Qc2LV3UuvC5te0mOIonSPh50G3V0edPs86HJ2LkuAz3EFaqCXMuyrDSoSF/cEiUoXOgOr12jQfcSDrvEw+pOHjbfToKse9EJp0DVp9wLZg65KXBwNdLNgllMscgCIrcQFABjWmgfdDzXo9sV6FLwie9BkcWEZ1rpCJb/naezTDap99tebuPzjNKmFijTXU8CaB90he4388QB8+NaiPd+sJii6wOu5wMMiT04do7M+9PjBA7n9ubZKe0qsSRKCoAaJKtWXPZEH3b6SqC9kr/EG1EAvZagSF3sPuhvmu5LFJUhZkmWUJdmS/zEpNy3GzzToimbSoA8CUEgDXVM1VsErHtUSgncicdHpdHjzzTfBM5IHXS8y0nmXH3hUOE6qJEoILH4QNGaP/YO3gnckLgRQK4laPeiSxMV7GnTWwVD1+Fd7BnnMtFlcbGJ6BCXNorS7cs5LS5pF++w1Lq+YCIKql9axOhjk1LX+5EG3jzco8XNNRPXh3Khzf5Co/TXdml4ysOe4gt8Z6FeuXMHatWtx8+ZNm+2CIGDfvn3YuHGjw3sUK6onmXG/18Ws6KXtJS6+kMVFo1tUbBh/MFJ5orRbyeLieuYBe88i4F8PJ4XFPmcuID2Q3r59GybeBAaAnij5uuyKKLMaD7ofGuj2cgcF70hcRLWSKMMwql5aChItOQ2633rQ5eulWdWgK4WKbINEHbyqAbw6pkWwk3voXPUmC7xUmIhhoGetHnR/yNrkUC2Xs91eYghK/AkQrJOcSGZWqiruDuwfTJTVUapB90FMJhOGDBmCkSNH4tChQ+r2jIwMdOzYEU899RSWLFmC+vXr4/PPPy/BlvouxCHNorzdHRp0WeISxAXZBYmW/B1DjYJnbYMmfb1YES+bPnq9tHyoBDYVuVARY/teIKFctLVZXARBwP/+9z9kW3IknbnASoYj6yhxUfKg+6PExdm5BrQedA+eb1FTqAiK5IDxnsTFznhRbuZ+O8UJAQGRjElIv3lrJVE4BonKU9krRal8gLweTAo0VnmrxIVjOeg4RYPu+7935f7lcxl7iJzFRc42pGM4CCBq9rHiYm+g63yogqo38CsDfcaMGejVqxdCQkJsts+dOxfp6ek4c+YMdu7cia+++govv/wykpKSSqilvot9mkW4Mw+64kHn9LKnl7G5oZQkip0gBbEx3imB7gYUiYteb5vFxRUvr9NCRQGc6SGvLC4AYJI16HoiS1zsPegchyDVg+77mlR71NUSOw+6V863tlCRJosLvBQkat931u896DykjP2SISn9J0kGeTgJEg0U7b2L5NnvgoxV0Spx0bM6tfgb7wdZmxRJh88FBIuCGiTKMiyC5JVek5ucHI4P3/L2kn4w8RJ+Y6AfPHgQmzdvxqxZsxze27BhA55++mmEhoYCAB577DGUKVMGW7du9XYzfR6rxEX6q9zP3RMkKldpYw1WDzpDfEziIr32l4AqHorRKRnonCIdcuECmJ8GPRA96ErxCmdZXExytUCDqOgg7Ax0hpE06CB+6UEvKIuLZyuJ2kpc1IdfL2VwUn/byjXN32/iSmYMjVyI0zo87DTo1uw1gfvwrcW+38r5LlCPrXrQJYmLXtGg+4GBnueqQUmfa02QKMdyCJLrdSir6cUlL+19IN6/nKEreBfPcPbsWfzzzz95vl+tWjW0b98eAJCdnY1nnnkGK1eudPCeA8DVq1dRs2ZN9TXLsqhWrRquXr3qsK/FYgHPWydPTk4OAMlA9XW5gztQJS6Q+qzqsYXi91/5Ueo5vVxYQwoSJYJQ4qJnQSPtIYSAldsmCAQc67vn3yKbPjpdMAghamows2AusL2K0cYyjvnvBdE3+1sclOIVOo6x6VudOnVgFk1gGKkYESEA4TjbOclyksSFSKsT/jY22nL32rZrvYse65MsyZAFLlBmmQi5LR4eS2XlROk7W8RrmnINKPFzLwhSOkBIXklCiBp7IoCA8DxACHjZOmM5qe3y6j94QSz5PngQwe58a1cO8u23wEsOD0Z64FEyY1lE6+/dZ+aAHUoKWXWOyxl+3HHfLhaCxoMORg28zSW8W9qlLVQknWvrdk/021vn39Xjl5iBfuHCBWzcuDHP9zt06KAa6NOmTUPv3r3RsWNHp/vyPA+DwWCzLSgoyMYQV5g9ezb+v703D5ekqs/H31NV3X3X2YfLNmgQARGF4EQww+ao0ccNRogYMEYxCvFRo8YnJGBENBrNNyqKPiSojJEgISJGCIsjLogQcQDhBwijiJFFuDN37tylb29Vp87vj7PU0lXdfW9XdVV3n/d5Zvp2Vd++tZw653Pe837ezyWXXNK0fXp6WjHwg4z5hSVQ6mJpaRHT0y4odUCpiz0zM4Bjtv+CFqhTGygA9VoDM3v2gDEGhzDs27sXjYls5UbVag2Uupif24fp6SW4rgtKGZ6d3o1SAZibmwMAxf7lAS5zQYWjw+y+eTDXgCvKBy5VltpKuMpLFVDqYnFhHtPTvLDRYrkKSl2Uy+1/v98ws5ffY7tRDZzb1q1bcffML8BcFyXKO8fZhUXYvs+soxQFBriui7nyfN9dm927bVDqwrEbgWOvVvjzvm9uHtPT6awMrK5WQcHgMhdz++ZgEkO0XYZatYr5lK/l4mJZtOlFTE876pzn5hcwPd356h1jLBf9gDG/D0XqcoUQZZiensbiwiJc5sIGg1OvYe/0NKq1Oj/PfbOYHllEvcHb/+zefZiermR2/GmCMQZb9IEze6ZBCFFj2LPTe0Dr8WOYtXs3bDAwBpTnF0Eb/HtqvmcmL20gjN17+PPtOvxYq3UXlLqo2yzTvsqc3a2MDBbmFmCIaL3cqCVyXPvm+BhWrZYxPQ3MzzdAqYtKNZnvD6NX918Sw+2QWYC+bds2bNu2re3ndu3aha9+9av40pe+hP/8z/8EwAPyO++8E/vvvz9OPPFETE1N4dlnnw383rPPPoupqamm77voootwwQUXqPfVahXr16/H1NTUUATo4xO7YZo1rFq1ClNTG1AsLsI0GdatW4+pjaXuvlwwGasnV+GAqQNAiAEGitWrJ2FE3IteoliswjQp1q1bh6mpcRQK+0BdFxs2bMTYCJ+WT01N5apTtl0bIAQWA/Y74ABgcjVGR8eAMlAoWJHt24+RERumaWPt2jWYmloNAFi7Zh9Ms4KR0bG2v99vGH9yH0xzCasmx9W5UUpx6623oviCcRimgZLIZly3YQPgP/9SCaUagWEYKJQKfXdtZisVmOYCxsdGAsc+OQmYZh3j46swNbU+nT9eKgJVXkV0/bp1MIkJwzAAw8VIoYSRlK/lyAiFaTawbu1qTE2txepVe2CaNYyPT2JqamPH3yNZrcz7AYtgziIAAUqFEqamprDeWQfDMOEaFBYhmJqagmktwTRd7LdxPaamRjEx3oBpOphctQZTU6uyO/4U4VAG05yFYRDsv//+AICRkhjD1q/H1IYWY1h1AY7BA68N6zdgssyvkWsw9czkpg2EsHdpCaa5gDHxfDdsF6a5DwDJtq9iDpgBQF7Tp8aBecC1kjmusbE9MM0q1qyexNTUfthXq8A0F2FZxVTOu1f3P/cBeqcwTROnnXYavv/976ttlFLs3LkTBx98ME488USccsopuOmmm3DeeecB4EH9Y489hlNOOaXp+wqFAgqFQtN2v3ZykMF81nuEEM92D92fvyvLKJtFGIYBUxTWYK6T+bWVkjXTFOetjocEEkezPk4/HJdLgwoMIFaBB+vSxcW12x6rd86G+qxcDmYsXwxRErDFglnB8u4jYwz33nsvjnn+8SCACtDl9ZRghin06Q4aHVzbvMERN7tYCLZhmVSW6v1mjAuxCGAQU+WfMDAQUQY8TYSfbVXEZQXnnIt+gLmQgjTLMPk5+WxrCaUAIUreb4nn2xTJJu4APtsSSovtK1CkXHvcNuetKokCBaOAgsjrcRgN/F4u2kAIUl5vqTYu7nW7c04bzKskahkmSuKaNkLXdKWQ9YgKFm/jfkvNtM67F/e/0+/OfYB+2GGHKeZcYmJiAh/4wAdw5plnAuCs+PHHH493v/vdOOaYY3DZZZfhrLPOwrHHHpvBEecbUvnUbLPYveaKCr20KSzsTMIDdOo4mTe0cCGXfigHTkXSrcmIyoQyVYDefune9emSJYy82HOlgCgfdIkG5asRJVc8Ay180PvBdi0Mv1bTj974oDMw1Z/4JkdAT5JEmzyiZSJZ1g4XK4XrwhFSfjnZsYgBEFlJlLfPcMGevk+O7QA0dM7AMhImqcOvKwgKpoWCSGi0GZUz2BSOOBmEK2qaPpMDnkuW0bG7ng+6SXxJokjGGCKukmjm7jU9Qt+4uPhx5plnYtOmTer9UUcdhXvuuQeTk5PYuXMnPvCBD+Cqq67K8Ajzi7BfcpJ2g1QV1eHBjymaVydFddKGnIDIYFVVUM1ZMpAf0v7L9NkCSmsw2oHzgLKfI82DWd7tJVcCz8WluVurUV6oaEQkgja5uBgGCozva7j9Z7MYNznpiV+yShLlaaLq2eKZ6On9XYFwQS41+c7xs90SvoqXysXFkD7owhWLsZX7gfcxvEmJt83sNGijVHnLW0TYLBLCnV1y4DTWCo5KjBUrgITkw8nFdeESniDObRZ5gF5DMi4uYXvJ3Pi/9whZE5srwte//vWmbUcccQQ++9nP9v5g+gyyXRM5mCkGPYHvhnQVEGyvdHPIgQ96uIKqZCB6UIl8xXCoDTAGixmqsI4sWOKwlTLoYl+/Bi8t4HdxkTBNE29605twN3sIAA/Qoxl0E0Uhf+nHSqKOYtCDkxPSiwmZzwedEAICA+Dilp48YOF27gWqqf/pdOB6tpXeaqSUuIi27VK1QiD78GGwWQxPSoBlBG2SQSeA5ask6hDGrSvDfUKOIPJim86bugyUsqaVs57BpQEGvSiriXYwPnWC8P2Wr20tNQcEfcmga6wczQw6f01iRiodRxSDLtgfJwe+0jQ0iMuVgzw/547w7rZA1I2S1e86CtDlpMTnjd0vBZpWgigfdMMw8KIXvQh11gAhwKjLXRwCFBz/oPBB789KonaMB3yvJC6ykqjhy+/glUTT+7MSTV7JSpOc44e7FVxRnRFETchlX0rliO04EQw63zXI7GKU379aMWnLoDvCvpJr+2VVZpuwXBTTa4XI8+7U/z1NKM9+PpkcEQF6UhIXxwm38cGfhPqhA/QhAwsFbYYvabBbqIIFQoYhJS6UZl8Iovm8+fs8D+KOw60RLXidsmXI6ncrY9AHeRB3Itg127bx6U9/GrV6DYCQuACgaA7Qi5zy7UsGPV6DntzzHQuZJMoFLsILHXzpuycMOn81QquCfdvGfayk0SRx8Rh0yaqGl//z3Kd1i6iKuf7Ewda/7PnLBwoV9ZHExT8Bz4Xcw3XVuG8QAyUVoCfz3MdNvjWDrjGQkNKGcJJoEpIHh8liCnwwsSTrkwN2IrxyIFm+PCs9qGLQvcdULct2JHHhr34NupqQDSADYdvRLHK9Xkedcl35mGgHDRYO0D2Ji92HDLocpMPn3pOy98p1hDO9BuFl6fl8pxca9FCSaKcBW17hZyWJ7EtFgB7BoIfP28m+u00NTiSD3mEbl5VE/RIXQnjQnvMlxfAKMOCfmGQZoMtCRQQWMVAyE2bQQwF6x6slAwIdoA8ZPDcT/koSDFTlTFpWaFPLsjlgJGmIZSMJTkzSguPwoNL0PaamkLjQDgaUqE49yQlZ3lC3+TUpFZu7tTrlqxGjTAbooc9IiQvrTw26bTfr74FeSlxkcotPRiX2pQ1P6sHfqzber0yy6yWJWlKDLh5ixyv97AvQIV6HgEEPBWz+nzvSoENKXCwUTJ/EJQervK0QDlQB/8Qkk0PiUHIszqAXhYtLIykXF9nGtYuLxjBAjpckZDeYTJJo0MXFUAx69p1fWO5hqMEsqyNqDypYX4v4ByMhcemgAwwv/ft/7lt2sQXqDX6PS4Xmbq0hruW4aAd2E4Pu2SzKz/YTZLl7K4ZB71WSqAHDW51K/Q9zyADFaGKS+3QQp1LiQjwXF+L5oPMfnCbLwUGWr0l4DLq3rWPLXEqFzaKUuMgAHbmXuLScmGStQRc/msSEISY9SRFAKrcmrEEfQIIpCjpAHzK4IbvBxJJEGfNp0PlDauVRgx5ycckz2yTtKf0SF1WwpBMNeuhe898X+3J83iuFZNBHfAy6ZVn46Ec/ihrjQTf3QSeww3GjtFkEg+06idQF6CWiEmSBHgVtrleoyHNxETaLPcgSbZJ69MHkuyUYU1rp1kmi/MeBkfZ0gCgXF6tTaY9MEiVcMsQ16EQw6PkO0KMY9FxMyFzKn3ORJCrlrTSh5z48CfUmJYl8fe6hA/Qhg2LQxfvEkkRdVzk5NDPo2T9NTRp0OYjnOA5zIjToBUsy6O1HYe+cfQz6ALu41Bv8pIpF73wZY3jssceEBp2hxAgcGGjYoRtvmDBAUBABUb3PWHTJoBdikkTTlbh4GnSvUBHh3ug9lLiEV8dWcs7FJx4Drv8G0KgndnzLBnV8lVlFoSKVJMo/4tp2c22HIfBBjypU5PVpnTDoPomLYQFE2CzmYIxqhSgXl3xo0INJoopAgpvIs+9NTPj7jj3vBwQ6QB8yeFKPoONB10tSTDyohPiq34lBJQcSF/k8N2nQcxyhOyJIlOwZ4DnkLCtJNMKSbCA16I1mBp1Sim9+85uoN+oAA0quAQem8kxXEBdmVBTaqDq13hx0QgjbkUn0SuIiJ+cEBgzp4iL2pY24KosrCVxGH7gbeOge4Le/Suz4lg03WD4d8Jh0FaALCtH0lbzPBaOaMsLVUwEveGsnaXKcBlwABghMn81iow8kLrK7MvOmQaf+JFFT5UpQgkQ6nSYXl1AF1UGHDtCHDF7BHv6qkkS7fZZ8+j75kEpmIw8Mepht6odl8CiJi7JZ7KBzikwS7YPzXilqIkCP1KC7UuJC4BBTaRsVZIBO+PWt0QwZ1BVAMeihc+9N0OarJOqboDOCnixRyT/hVRJdeRs3hB0napUkDm1l8FVnVBIXEajLPpY2bLHdL3kY3GdbIizrATr3vZdEkaWsKy0ApC8Y9CiJSy6K9jBXJYgbxODtlRAxOe++IYZXTHJTQbVH0AH6kCHOM7hrRtUNPqiAj0FPqKpYN5DnnYa9ZFpwhHY/wKBbnOGlnSSJhlYN+M/8dRBZtrqQrUS5uPCAm2GEETgwlSWjggiARkQyXq3PGPQ4H/SeMegAIFzQg4WK0h9Fw2XQu1n6J1LaUqsmc3ArgeuqQunKB13KBcVEyLVF32A2B6qD+GxLRGuxO9Ogy/5UjktF5YOefw16VJKompBlOYbJJFGpQScy/4Ql0uko4iHC/71vk8CXAR2gDxk8pguB16779FDJX/9rHpJEVcIk8WbiQL7ZJmlPKQcUwKsk2kkWe1Shoo71mn0IKXEpFf0TEgMvOOooOC4FAVBgiJG48N+RAXqlzwJ0R5xPrA96qkmiLpia+BogpLfDCg3rVLtIhCYNyaBnGaB7NotmnMRFBOiRRcgGOHCJWhXsNM/CFpJBmWdiCQ26TZB7Bp22cK/JRSVR4TikCmqJfd0iSns/TDp0HaAPGTwf9OBycBJJory4BlHFdAypR8tB5xfWY3v2kvl9yJXExRfwWIJB7yhJVC79kyjWJamjzA+kxGXEJ/MwTROvP/31YAZQIgUYhCeJNktc+MAyJiUuTn9JXCR7GOeDnuqETDHoIklU/JwUi9YO4ZWibrS5uWDQqc8ZI1xJVDHoom+I0iQP4sMtEMUkd7oq6LhSFsSvpdSgO33AoKuVA98EPA82i4w6wSRRNZFM5tmPOm+zw5yDQYAO0IcMMiCVMV9iyZKhbG4gX0mizRVU88+gO5EM+jICdNrMNvVDcuxKwBhDw5YuLsEk0Ru/ewOIC5SMAggEg95G4lJ1MgzQVgBbMOhZ+aBLEMmgk95VEg1Xl1yxcw11QBzRV2WpQWeuzwc9VElUMOuu4yWJSnRc8r6PEZX4Ls/bbROw2WIltyCe8YLJbRb7KUCPYpKzrBzrirGdS9tEFWEQwaB3f2AqQM+be02PoAP0IYOqqBkKVLtn0KnnPEBkkqgM0LPv/DztffA13xr05gDdlDaLHWh7w841gC+hKr+nvSLIgLtgGYFBzHVdPPrwowAISjLBFqYKaBXE74xCaND7zGZRDmTZ2Cx6lUQJoFxcKNATDbqcbEpmzVjpqoHfWjFjDToN5fMEpAMAmGDQg3aD/HWQl/5bVtRs09TC/am0WewHF5dI//ccrJi4YmBV9UXE5DwpFxcawaAr84kBbucSOkAfNog2Ha4k2vVDHpUkKp0HWA4Y9FAxE68ceFZH1B5yYhNg0JUPevv7FXau8f88aJ1bLUJ/HsYIsUAIERr0GAYd/LX/GPTmZCqgRy4uvkqixMeiMYJe1CmKLVS07HP2B+UZS1xkj9mkQReOOUww/X5N8jAkiUZq0Ds8b0e6uAhpi+WXuOSARGqFSP/3HCT8y9VxE8FkZhfJJokO20qRhA7QhwxesiTEa3xAs7wvbl6WVRndPWDR2kFVEg1bsfUBgy4HacCTuHRSqU2VQI8oVJTj014R6hH68zBKRA7IUS4u0mZRurj0mwbdW0Hwo6cuLoSz58q6FegJgy7bedcVNev5Y9Dl5JwQIthJLh+QAXqU7V6eSYdu0bKiZjsfdBFMFgIa9H6pJMpfo+53lmQLDTmNyVVzN6HEWxpx3nKlbNBIpijoAH3IEE6oIkkxyVLiQryA0lpGWfq0IVkGpUHvAy9VxU5E2SySziuJBgoVDagGvW5LBj3kA26aOP41W8AIQ4lYIARwYCjGXUEE6B6D3l8uLpJBN83g9t4w6F4VYUIIiCpUxHpaSVQG5itOjK3nhEFX5dNJ4NlXlZmJF6AHLFRV3YnBerb9iHT16HDFRNksinGpoGwWkXsGPVKDngPfezm2S1lboFBRgpVEtc2ixlCAhUreezaLySeJqgEl487P79QSPu9cu7goxsdS2zwf9PYrEzRS4iIGs/ye9orgSVzCDLKB9c/ZABCgBFME6GZEgM4j21EmNeiDwaCbvWBVlcTFnyjWQwZdTUQhXlcYqNZ9k7J61j7oQZtFwEd4EKZsFqOYxUEOXCL9wDtcMbFZOECXNov5Z9CjNOhekmiWEhexyhsY8wmPBRJMEh02v38JHaAPGWSblgGqHMy6jlOpP0k0yKB34jiSJrwiRc1lsfO8HOwVKvIGaWKasEAAxtpOfKJ0yStOoMs56g1+PuEqorZt45YrbgBxCUaICQKAwkStHsOgM/7afwy68EEPFyrqBavKGGfLARB/oSKCnmQjU+VWFJSvLV/i4rvntWp2OjDqqBUJI8ygk6BDRnSV4MF6tv1QlUQjCva0l7iIJFGlQTfRb5VE/StkudCghyQuvJJoMkmi1GWKQIvSoA/yRFRCB+hDBqXFVgV7+PuuO3XWnCSqnAcy7vzcCCZZFSrK8TPuiAqsfgYdpgVLHLPdwr6SMda6+lyOJyYrQaskUdnJl8AHDxsmquEAXaxMjIrN/RagK41qk80if01b4iK/3SCGkrgw3/9pwd9veUmiYt9yB3C/rIWxoKtLL2HbojojCSaIy6R7wjwXF3/g0geyvW4Ryah2WLBHOl/J/tQUE3YXgOPYiR9rkojqy/MQqHpGBkFrZRfoPkCPOGdgcMewKOgAfcgQzoL3pB5dfrE/SVQ6D8gAnWUcoIeKMwF9UqhIatB9y9wwTZhMylTieyj/QEYiznvQWDbpgT5SjO/SuMSFu7jUwxIXiw/aI+La9l2AHsOg92QwY8zH+HrtrRcadFWMK4pR7cZmEchOh243FNnhf/b91USjkkQH9dn2IyxnAvzWsa3PW/qgWybXnhNCVFVRWbU5r4iSsJk5WDFxxdhu+pKZAeHX36VsKKpIEZCPiUmvoAP0IYPsw5TNIkmIdaG+JFH/chfyEKBHaLH7oVCRCtB9DLphcAadMbU/CnG2e0YfrBysBPUYDToAENGhl5ghJC4RSaIFwaDLOjV95uIibSPDg1lPdKquz2ZR6NBBIGwW021oaiIamISusE8LB+RZFStybDgiSdQvcfFcXBgYlRKXfGmS00a0i4s87za/G9KgA95Y5fRJgG4GuJrOzjtNUNkOw2M+0HX+SdS9Bjp37RkE6AB9yBCWeyTFJDOXNiWJmqZ0cclYgx6S9QD50O+1g1o+DAToJkxZCKbFoKICdDP4iPfDea8EdWGbGA7QC4UCnn/mi8EMhhFmgBDAJhFJooJBHxWDXd8miYYGMzlBayrMlCj8PuhEODoQvsydcpKo0p8HF5n4vmUz6KFVk6wYdMdWfalJopJEAUQw6MOw9B/2vOc/89d2TLKSDAoGHfD8u6WWOq9wIvrzPFTUDDuNmULX7yagQY8N0OXEZMDGsCjoAH3I4DHo/DUpRtWlnt2Sp0EXA0rGDHr4nAE/g57fh1xet0CATggsJpmT9gF6E6Oag2XRNCAD7rDExXVdzP5uBmBACTxAp5EadD5oj4jr1ncSFxmgh5JkvQA93SRRpiqJEpCAi0vaEpfmgG3FibFNDHpWEhdbSIZIIEBXrlgAQCMKFeWgsmTaaOXi0m7lwBaEh2l4AbrUTMsE0ryilfY+SyZZOokFnNuIqNPRpcRF3WsjOkDXDLrGwCEuSbRbBl2yudIPFfBLXLKldKKqz3krBxkcUIdQtmCmFdhuSQbdiS9HH+UfC3hL4nk+75VASlyKheD5Ukox87OnQRjBqJC4RPqgywBd6CJqfRSguy7z+UMH90lXm0a4MFOSYEwkNULYLIo21gMXl3CRIsCnSV5ufCBdXITcKVMGXcoFfZ2WZZhc4kKYYtCD9nP8dZADF3W/V1CgiQo3sYLlD9ClxCXnDHqUH3gOGXTL59Xf7SATNSkBtAZdY4ARDlZVYlGXbd0r+evvOCWDnrXERUpvoli2TA6pI0hpUIBBB2CJx9ZuoZOWkoZiKECXl2DQWLZ6DIPux5jLNbw2rOYk0QIftEft/mPQ4xKCAW9Ab6QpcXHdgA86/C4uKc8EI5MGJbO43L8tA/TV6/hrkgG66wJf+X/Addvbf9axhQ96WIMuXVygZh+JrBz0EaJkD/K82zLogvDwS1ws5TSWbwbdK0QWkQydpYuLGNubqocnYF0ZSzL1Qf5YUtAB+pAhnCRKEmrsUuJi+QcUGaBn7IMu5wdmBIPedYGmFOEV1igEtisNegtrMCVxafLF9n4eJJlLXKEiP8b8SaJ1N7hqJDToRYfCIAS267RMws0T4hKC/dsoZSnebwbmk8ypQBEMSNnJhUawbMZKAxcVoK/lr0kmiS7OA79/Anj4PsV+x8L2Megk7OIiGHTarEH3NMnJHXbeEBWgd6rFljaLfomLmvT0CYNuRSSJZnm/ZZ5U0BhCevUno0E3QxIXeQ00g64xcFCOJnJATShJVDIQhq9JGXmRuIQmJUB/SD0kg242SVzEsmxHEpfgI058AdQAxeexDLphGHAOMAAwjLpcg84MCy5jQV228EEnjoNRaxRA/zi5eAmiEQ42hKg2kJoO3efiEmZ9WcoBurJZDDDJvv3LaeSyeqgK0BNk0P163H17Wn9WJYmSoOOIIfW9AFEuLt6veVVjB+jBDiGKeOjUXlIG6JbZrEGnOZ+MRz3juWDQ3WAxPY9BR3JJojHOVIPcziV0gD5kiLNZ7FrioiqK5VDiEqFBJ6F9eYQjnOX9AwoAWGpJtwWDbsezqqTDAa2fUBOVRIuhJEnTNLFwuANmCIkLAFLg7TKQKCoYdDg2SiYP1vvFySWKXfMj9URRXyVRw9+vEJJIwZJWkOfutxskhPi8sZfxZbUUJS7+Z3Vmd+vPOiJJlHjMJABYRLq4eAx61MRkkDXoLRn0thIX4eIiJuOA5zPflzaLHRZoShNybDeMiCTRLiUuck4bV6hIM+gaAwfP9YC/V0miXQZrcqkrwKAbOZG4yMRY/2BmJDMxSRNq+TCkQfeswVoE6DHsA+BNovJ87stFXRUqCp6v4zgYfcgFcYEx0eETEYwHEkWFBh22jTHBoFf6RIfuSVyiu/OSSJyVxZwSBWPwwnOoKqIBJ5cUqzTGVhsknQVtCoxFSFwSDND9spaZ6daftYUPOkggQJf6fgqAyL4hws1kkDXoNKJf68j33nX5xAbBpHuPQc/WaawdaMSKaB7utydx4ddRafoTYNBlHlX42c6DvWSvoAP0IYN8ZjybRbE9oSRRK49JoiFZD9C5d26WcCJcBwCfNVgLiUtc5wZ4ntF5PvflIq5QEWMMo3stAEQF6IYIxmsBBl1cY8fGiFXi+/ssQI+ajAHeoN5Ig0FnQQ90ldsidwPtNdddIFzXQcJYrhc6dTjjZxrAxCq+rZ5ggG77Jil7O2DQQzUlAOniAjiEgUQw6OZKCzT1EWwl9VimBp06qviTSfyyIWmzmF+Ji+uyyGToPOQcuJC6/pDEBUhA4sJfwy4ueSjQ1CtY7T+SPcrlMubm5gLbJiYmsGbNmsC2er2OxcVFbNiwoXcH12dotllMWuLiY3xUkmi2gaDswPqNQZeFNcywxEUmiXZQSTTs4gIMZha8CtALzQG6xKhMFhYSl7odHaCPWiMA+keDTiOCFj+k9WQqxYoYU+tjfotVQ1S9dAmUHCMNxCWSmctt44Itd4slGCU+QVOMehLwryLsbcGgM+azWQxp0MXEnF9T2Td4v7riAk19BKeFBr3lagmlwhnHY3kBoCCCdSfHDLoKzkMuTfnQoFPADFcSFYnMXQ4w8rw1g55z/Ou//isOO+wwnHDCCerfZz/7WbWfMYYPfehDWLNmDZ773Ofi+c9/Pn72s59leMT5hWScFIOeWJIoH4SDjA/X+uWRQZfnn2cW2WGygyoGtksG3W7JoMezqoNYTdSTuAS7tDrl16hoFmCJANUsColLpAbdwYjJA7Qq7Q8GXVooRuUb+Len4oXuiuk3CQYPUurigqUqcZExQFOAvtxBXATjrDjiX2JK5BgBBK/BzO74xFmX8kmPuJZ+wkNWaXQIYFBpGeifFA1+4BKVONhRgSaXCtlQMED3GPT8atC9KqJhLTZ/zTxAh2cFbAZ80Ltk0GOcyPJw3r1CXzDoAHDqqafi1ltvjdx3xRVX4Oqrr8b999+Pww47DB/72Mdw+umn4/HHH8fY2FiPjzTfUBIXI8SgdzkWSRcXC36NnNCj5VmDnmMWmSKGQZedYAtmMq5MMjCYA7lMEg1LXOqsgceetxujhREvsU5IXKp+Dbpp8RkcczEqJkT94oUeV9BDIlUXF8cRVS+Dk3PJoDOCdDXoil0MbjeXOwmVAXqh6K/elsQhcvivQa0CLJWBicnmzwkpjGPIZFvvxOTE3AWL1KCrgj35JYO7hkObpXsd2Q1SCoc0O+MozXTGJFIrOG70863OO0MrMpUk6ndxIWJinpSLS9x5D0GA3hcMusTs7CwajWbW8Otf/zre8Y534IgjjoBpmrjwwguxtLQUG9APMyRTbqpBNbh9pXDdYMlfwAsss5e4RGjQlfY+vw+57HjDGnRTVb9r74NejEgc9HtjDwribBZrtI7FyRqXrUhZQCmCQQfAhCRrRKz89IsG3Wnhgw54EpdUkkQdm1spEqJYc8DrB9LWoNMYiUtHiYN+iGNkVsGfOZ/IMfq/XyFO5mLz8Y2K4/dXEpWTHocAxG1m0PMQsKUNJ8LZoyOpBxUMOkHIujL/Epe4Ogd5CFSplGEGNOjcvcml3V3T2AB9iFxcMmPQFxcXMT8/H7t/bGwM69Zxu6vJyUk88sgjOProozEzM4OXvexluPzyy3HUUUcBAB5++GG8733vU787OjqKww47DA8//DDe9KY3Bb7Xtm04vs6yWuXaQ8ZY10FqP8A7RX6+/sqS3Zy/49OgM5W4JTo/5oK5rjfw9Rhe9VSijs0vcZH3Pm/334b0OrYCx2bCswaLO2ZbBGOW1Tz58iQPbu7OeaWQAXqxEDzfhdoi/vD+Q7BwEsDEc28VZZIoVZ9ljPEA3aUYJXx/xa71xfVREheTRB5vqvfbbkAOw4SE/z53HGG2nZoXuqdBD953FaA7HZ6zL3tefdplyR23HSKW9u4GDnle8+cE0y4DdANef6rkGD4G3fLdc3nkvCiV21RVdhDgJb/DN87wV4e26MOpIxh07oLVdE1dJzAO5Om5d6Q0zwg+XzJubXneKUNVEjVM736IAJ3SBkhXMYX87uCz7c+1SPq8e3X/O/3+zAL07du345//+Z9j95922mn48pe/DAA477zzcN555wEAFhYW8J73vAevf/3r8cgjj6BUKmFpaQmTk8HlwlWrVmFpaanpez/5yU/ikksuado+PT09FHKYuu2AUhd7986gUTWwVK6AUheLi2VMt3H/aoXFpUUAAKMM0+KLFuYXAHAGffqZZ5rXoXuEvTM2KHVh23V1bOXyEih1sbBQxvS0q5KQ8zSoOSJoWFwog/lvjssAAswvzqvzCWN2jt/XerXS/BmXt4Fnpmdgun2jcouFQxkaNoVhAHtndgfu4e/3PgMAMChBo1qBRV00HN4eds/MY3qaB0SMMawBgUEp6FIdrutiz9xM7PXNE2Zm6qJ91yKP17H5/t179mF6XYLVMQGY+/agJNqpS131913qgoGBui5m9+yGPTKR6N+V2LuXn1ujUQ+cO5X3eM8ewGnfxgt7Z7CGUjRsGwuzs1hPXdBGHbMJ3f/R2b2Y8NH55d3TqEZ8t7lvD9ZRFw54kD2/bx7TlH+uXq3BdV04zAAoP79KZRHT0x7h5LouGAOefXY6IOkbFFRrDVDqYt++vTBdPp7sm6e8r6s3Yp9Xc3aPyukpzy9i2uSfcxp8olMT7YcxlruxYPc+fn7MdQLnNz/Pr8XSUjWzfqphN4ARoF7zrr0Myufn5uB0cVx7Z6vivgbHsIqIWebnu4tZotCr+y+J4XbIbHR+//vfj/e///3L/r1Vq1bh0ksvxcaNG/Hggw9i8+bNWLt2LWZnZwOfm52dxdq1a5t+/6KLLsIFF1yg3lerVaxfvx5TU1NDEaCbxhxME9hvv41YNW5h1aq9MM0qxscnMDU1teLv3VsqAWWgWCio73nGmAEIATUIptavB6Q7Qo+xr1aBaS5gpFRSx7Z69QxMs4ax8XFMTe0HAJiamspNpwxwOzUwYOPG/bHKd29GCiXAAUZGS7H3bHR0D0yzirVrJjE1tTGwb3ysAtN0sWrVWkxN9X+bX6pSmOYsRksG9t9//8C+xxpPAADWTKxB0ZwHTAOr166GaQKFknfvGWNwSiUYdg0bJ9fAmDVgjphdPRO9wsSz8zDNMiYnxiKPd/UqB6ZpY2xiFaam1iT7x10bZZNLLwqWpf5+wSpwL3STYN2qSSCl6/i7mUWYZhnjY6OBcx8dKcM061i7dgOmpjrodyrzgGmiUCxhYsNGENOA4TufrvHYaMAjb9XEROCZVnAbgGnANQ0YhoGNGzZgai3/3OT0JAzThGsymMyFaRpYv3Y1pqa8ca5gzYK6DBs27hfri9/PIMY8TNPBgftvxNpVfKXLLNkwzTkQs8X9Yg6oAYAQrF+/AVP78c+N/2acf69JMDU1pZjNPI0FDdRgmnMYHS0Gzm/34hJMcxGF4kh2/ZRo0xO++KFgWKCoY2x8DKNdHNf4xF6YZgWrVwVjkzVrZmGaVYyMRvd33aBX9z/3Afpy4LquqlQFQM1wZEC9efNm3HnnnfiLv/gLAMDevXvx6KOPYvPmzU3fVSgUUCgUmraTkAvBoEKVxjYNXvbdZzfYzfkrLRox1ffI5UOV1JTR9fUniXrHRsQ+ou593tqA1O5bhULguJQPOrVjj9evWwx/piBt92h+WKJuUBfuJCNFo+l8qrQGx6RYZY2C0L0AgOJIAYCNeoMFPs+E1n+CcA36klPti+vjL1QUdbxFlSSawv32JSoT4v19XklUbHfs1J59rz8LWdCZy+/XGAAYBMQw+aEzltxxhxO6qRP93UKGJSUuluH1p1I7TQlgMBcEDFbonpsmAXUZXJavviwpeC4u3nlLRxeuoow5Z5cqiUvR8PrTgimdxqjn4Z+zsUAuvFihNi7Pm7oss2NlPomLGltFaiPzXdOVwKskGmzjfv/3NM67F/e/0+/uiyn2aaedhmuuuQa7du3CD3/4Q5xzzjnYsmULjjzySADABz7wAVx11VX4xje+gQceeADvfOc7cfTRR+PUU0/N9sBzCBmsyuaRtM2i6X+QiMUZdIJUvZDbIcqKTRVoyrGTiUOkjnwksF0mjrWqfmf7BrIwioUUXT0yQKXGr9PoSLOEqs4aePDFT2N8ZExlmBVGhAa9EUoSFVaLE+D7y41miVweIRPn2iaJpuGD7tjc85iQZh90iIIlPUgSDSeSqbL3nT7fqv8j6bq4yCqWcQ4XUoMuDiFQVEe6NxlcbW6BxibQDVICuB9R1nsdJQ1Sz2bRjLJZZH2QJBp7r3t+SApKg+6rzuq5hHX33HtJosHt2gc9Z/jCF76AHTt24PTTT8eFF16IV7ziFbjxxhsVq/6a17wG27dvx5e//GWcccYZmJiYwE033aRs/jQ8hCvveYFqd98bLvnLfxZuI4SlOki3Q1S1QW/lIL8PuWTQm20WeWdot3BxaeXsIbelUrgmA1TrvO2NjTR3Z0uNCtbtHceo4dksFkeES0vIxUUGT+Pi+pbtZPXaaSHKes6PVCdkjq2SKv0OTpwhEjaLKU7O4yrmLtsHXTEXxG9tlcgxAvD6v5KYbMddE5FM6koXlyYfdICaJsCAApym53sQaxz4YUdMyMxOLHNVkihRK5D8e3jfmucAncbYqHbk/54yqKokGjGR7NIZJ/a8c+Be0yv0hcTl0EMPxfbt21t+5i1veQve8pa39OiI+hfSOSxcSbTbschlEQG6HFCATM15PYMGH8NnBPflDdSlMhcUZpPNovTujb+mrYrXFNP0xc4AikEvNU/IK3YVz3liPUZP8GwWiyO826vGMuj8dalPAvQ4GzYJv4tL4nBkfUYS9EEXTHTaDLpk2ZoC1eXWd/C5uKTCoAt/c5RGgEo5nvYUDHoU2ysDS2qZYABKsJuCl0FmFxljkSsmHQVsrqgqQcI2i7Ivze/1imvjVg4C1bAPOuBVFO42QJeTsbiVAye/c6rE0BcMukZykB2RqiS63KXguO+VDLqPpvbK/iLVYiXtIGUsvhwtr0BTTjtm3vExmCAgVnAeXZBa1BZLiK0KFaVaWTIDVGq87Y1HMOhVmyfjjBZKgFhxKI1yBr0eDtAFgz7BhMTF7g+Jix1TcU+iKFdM0rjfjs0LFYX+NFE+6AxoUfG26z8fW8wkuL8tmD9AT2H2Lle7iiJhtU2ALv+yEcegAyjCUfdWoh8KsK0U1CdV9DvUqEC1VV/uK1QUmPQIDbqdYwY97vn22w1mBUdJXJpXzlsRSJ2gLYM+gJPQMHSAPmzwJUz6X7uNU2MlLkRINTIUysnn2PAx6GbOGXRHFiJh8EqPCyjdZKtKokMkcWmlQa+IYkOjpp9Bj9agS4nLGOONo18YdMUqxjHoQuLSSKmSaCSDLpJEXYJUGfTYIi4qUF3mOfsZ9CQLrEkGfWSUv8axi3ZQg24F+lP+s20aYAwoMidC9sBfB7GIS1zFXEUytfRBp7DF5wp+Bl08890Gk2ki7rzzULDHlRKXCGmr26W0LW7ybS138t3H0AH6kEHOOsMMerdMsnxQA6WpJeOTeZKoOOdIDXoWR9QeyhWHkSb/eKuDxKZGiwDdSxrM6ckvE1XBoI+VIhh0WsOeDYsYl4m2honRkZhKokJKNEr5IFOnDTVRyjNaVY3l29OUuNi8rDcJToB5VVGSeiXROHZx2ZVEZcGqtCQujk/iAsT3h+JaubKojp/tlStnIgovwk5uYtIHiEoQBYLuXLGnTalIZg5OeixLVrvOL1nhtJF6ZEkySYmL5ZNhqgTxLiUu7SqJDmIbD0MH6EOEQKU90eaTGouiJC6y7C/NOkk0pLsH/Oedz4fccR2AMZgMnvODgKXKU7eXuER5IRcGTYNelwx6RIDu1vDUpn0YF0vZsCyMFPnn4lxciONgvMAtXBf7wMnFjmHYJLwVkzSTRIkIyjlUwCQ+kxbiVg8kk9x5kmiUBj3ByEf2fx1KXOST7V+VkMyvbRIwMBThtEiOTeaw8wSbxufVqOTYOFbVjXZxsQwRoOd0HABaMOhmDhh0VZHVtyqBZJJEnZhn28rBefcKOkAfIvj7IOVXnLDEJcigW0LigowlLs0a9GUnkfUYjtCsWowE7WfgD9Bb2Cza0awLkDKjmgGkBn0sSuJSr+F5j21ESV6qQhEjgmmPc3GBY6sAveJ0VlAiS7SSMwFpu7g43KkFCElcePEiN+XJeZwFnbFcls3v4qI06Gkw6FLiEvPsCRcXKhn0iBVJxyAAQ3SAPsA2izIpMCrXom1yLHWEKxYJJIlKFxebuLkdDGITobN27GFMrTwYvkmP/DmpAN1vj+x/n6W9ZK+gA/Qhgirq4Wvwkizq9iGXcgs/OxFg0HPggx7l4pLXRBNHJNZZ4ew7eGxFK92kYpsKLTToA5IkWhWBdpTNYsWuYtXiKEZdsa9YCjDo/hUUyaDDsTFR4BUG+8EL3Y4ZwCWkpKmemsQFTUV3DFmsRHwmLfgL1/jhOVx0+EWqH/BNiFORuAgGPW7SEkoSNQMMurAEFExDKULikvd+rRvEed4DfsvB2F9WDLoVdhojRJBI+ZSzxUl7Mnfscann1x9ls9h1kih/bZJxaQZdYxChghFfezcSsllUWjQ/40NyokGP8kHPO4NuywC9+RG1OkhsauXskWrSYAZYqooAPcJmsUo5Az4mA/RCAQXLgCUqLvqdbJhi0D2JSz94oTsxXuASqUqaZICOINurfND5ASb/dwXiJifmsusc+Bh0tSmFJNFSmyRRWahI1kCI0KDbBj/aImtm0DMP2lJEnOc90MHKAaWwRUGtAIMuqzKTbI0MWqGdFjuzw3bEqgQJJognFaDL+g7N0h7+OohtPAwdoA8RVEXNKD/wbpNE3WYGnbMTQuKSAw16oJJoQhVU0wKVEpcWDHoricswubjEFSpijKEqXFxGXGnhwBnM8VHeTpdq3jVUAbrdwIQI0Jf6wGqxUwY9NR90EfiQcJIoEWFvi4Ja3f/5uMRB/tqx1CNK4pKoBr3DJFHp4qLcMbw27Q/QwTiDHtbn5p146AatrGPbBm0+tteKmPQ4BLm9aO202JnJmQIMenjlPIkkUf46TDKuMHSAPkSQQbjfzSSpQkWq5K8/QFc+6NmyE6wFg57XZCrHqQPwEm78KHRQ/c5ukSRaTDNpMAN4NovBc224NhxG8Zsj9mBEnmqRJ4tKvbpk3wEA0omAOpgoconLYlSAPj8L7H4muRPoEu180NNOEvU8u30TYMGgp22z2JZdXGahIhaoJJpCkqgM0OOCQccGA4N8sv2rEqr+AeErE0U4KJjBNr9s//c+QquCXO3uN5NsL6KK6WUvw2wF1cbDWuysV0scT9dvRtiBul1OeNTKYJwGXTPoGoMEf7E8CWWz2OVY5EZUFFNLXZlLXJq3JbVykBYUg06iBqMOAvRWEhcRtA9aoaKwxEX6mJuTBRDJYBZ4gC6LGkn2HfBp0O2GlyRqRySJXnoxcPmngHotsXPoBm2TRNOUuFDPBx1hFxfJoNvpMehxQZtXKbgbBj1JDboo1iQD9LhJi22ripcmMQKrEjJAb4gE0iKcsAPrQFvQxRWuAdqzql5/GrymJuGrvJxBz7nEpYVTUSYrwY6jipSZkRKX7sZ8OdkaJhlXGDpAHyLI5hxlN9htoKoYdJ8loHRycMDAclFJ1C9xSWblIC0oF5eWGvT4WVVLiUth0CQu0Qz6QqMMwgiee88aODURaIsAfUxKXKoREhfHURKXJg267auKWcuHw4u0iywVY3zQU5e4oMkHXSaJcovVNJNEo3XJy2bZVIBuePOMJPuGJgY9XoPO1VhBXS/gqyQqJC5FZjetkA22zWILBl1MVOImJjblz60ZuqZqVSLjYnqtECfjIoRkK2nyS1zCDk4AaJcHpUimmCTRnN6uRKED9CGCGypSBCRosxjh4mIaJkwx2tEUy323gxysjIC0h7/mlWlynPgA3exI4hKfUDWoEpfxkM3iYqPsvZGBdaEQ+Kxf4uIx6LYvSTQkcVmYw4xF8XTByc2SeF0G6IXo7lytmKRxv+2GkrgQhAdp0fZSvE5tB/FlFioCkJIGPRSgt/BBd0ThJzNUQbgoVs4aYEriElK4DPTyf1ygCrSvqimrLvtNDABPjpFrDbrbSnuf4f12bCVxCSSJyolkty4uMec9TC4uVvuPaAwK5BgUZbPYbaBKIyQuAJ9ZU3BGOKvGpjToTRrZ/FYSdQTjY5F4Bt1pEUC00msOUqEihzLYjguDEMUUSwSCaxWg8yRRmVDqTxIN+qBzDfpSmEGf34ePHTSLGYvi3+sVlJI7lRWjLqRKIxkx6K5ycgj1KyT9QkVxHtHJFCpi/F+EzGxZoJQz5oSoFZxOGHQz1JfK5EZZGmqEOAG5BrCC5Ng+Qssk0TZVNdWKZOQ1JZnLMFuh9cQEsCHud6Fpd7qgDr9uoclkYhr0uAJNA2wlGoZm0IcINIpBTzxJNBiGF8TDamfIoLsRDLp8yHPLoIsBJSpJ1BJVMePKU7suUwN0VICuArYBkLhI/fnoiNEUrHAGncEYMUEaIkgUSaLSxaVa8zHovgB9Uvqghxh0d24Wvy84qBGGpdpi0qezIkgGvRgToKeaJEq9QkVBFxfOoLtATzToseXAl+niwlSATgLbu4KcoFgFXxZnCw26KEkflmPIqpdS9T9iNH+HNcASlzgtNtCeVZUa9PA19TToOZa4dOP/niYo5ZNzRCXexo9PnSLuvHUlUY3BhGjPRiBA569dM+jSFiyUtaR8ZmmWAXozg+5p77M4ovaQS7LhAQXwdP5xEhc/8xAOWoHBKlQk5S1RVUTLjQqYAWx6/eGwXBHMSA26ZND9GnTp4uI4GCtwv+owg16dm1bDjm3nI0lUBugjxfZJooknkzm2ShI1AhIXkSSasjtGXPEaKd3reAz3a9CBIIveLfwBumQa4xh0mSQK0iRxUUmiogWW0HxdPU1y/z/bYbRKfG/ney8JjwKJvqZZV7tuhW4mJqnCEQx6SOJiJOaD3s6hafDaeBg6QB8iyPYcVVGz26benkHPMElUTkwikkTzOpBJzX54SRbwylPHSVxayVv49sEpVKQ80EvNXdmiXQYYYP+uArfBbSu9AL3ZBx1WlA96MEBfXNitfrYb+QjQa3ZrDbppEpgGAWMseabNlpVEwxNgzkJziUv6GvRYictKfNABH4uRRIAuzt+yvDYWdyOorRLvwkmiiuxg8QH6INsstqokKsexWA06k4RHSIJp8JUem7D8u7jESFyAjIJVn8TFCvigJ2Wz2JpBz+l8KlHoAH2IoJjkCB/0bp9vNy5AV0V1sndx8a8ctNMsZg3HlUlNERIXiweZTkzwoHS54QwygUEqVFSpxjPo0sXl9zt/ByotEYtcNT6hXFyiJC4OJpTEJRSgl/eqn20n+wCdUi5nIoTETsgA754nrkN3PJvFwMRfDC1MfCYt2Cp4CTuerNTFRW5QS4tdHiFCDLqMqFrZLHLdeziYlPUPFINOmvvUQbZZbOXi0q5oj1yRLITGJ5NYvJgeQW4jvtYFmlqfd6qgNNUkUW8lOLg903PuMXSAPkSQY1Ck1CMpiYsRLXHJVIOuGHRvW9590JWLSysGPUbjF+dsIVFUNov5PPfloFL3NOhhlBv+JFHpg86v3VgrH3THxlhhFIQQVOxqoGJreWmf+rmRA4lLXbHn0XImiWIhJe97asMVmmm/xIUILbdLkG4l0ZigzVjuBNyfJMq/QGxPUOJSKHiJyG2TRCM06CEGvRjFoGepSU4ZrQJVo815e5LBMIMugsk8M+gdSHsyc3GRSaIBDbqsJNpdI6QxRJPpG7vzWgk8KegAfYigKolGMMndJ4mK2W6IoZBLX1ky6FStHERNTLI4ovaQ1ysqQJc2i3E+6HFBi0SqhWt6DE+DHiNxkWhycWnFoNswiIExi+vQq47wO2cMi9V59XnHzm7SKdHOA10itVWTOAad+Bh0SlN70OKTRPnrshl0yZwnqUG3I5JEWzDoDhEMepjsEH2rLZjJEiIY9HYl77PAk48Di/PtP9cGXqAalTjfOlClckUyUtfPa3X0I4PuJUz29JA4qJcGagUC9PZ1OjqBtJcMM+h+//dBnIj6oQP0IYJi0CP9wLv7blVJ1Ax3gILtzdDCKiwvBfzuNTkayHxQtmBGBIMudNQOiT52GYQV2pR+T8V2r8eQRYrCVUQBYLGxBEYYXviSF8GQwbRycYmwWfQx6ACwqjghvkcE+tUlLPqCojxIXCQj3nmAnlaSKED8lUTFz267gLRLxLkVGcuWuPB2xGTnmGSALs/dnyQaFVlQB2AuqPjbTRIXI2ivWoyo1KgCl7ws/z/7NHDl54EvXNz1V3mBavO+dvaSnmSw2QYY6M9KooAn98hE0kQdvvIQlriQZF1cwsW4gOHxQtcB+hCBqlXcZia520DVURKXMIMuWJ8cuLgEK4nKfVkcUXtQMViEB2kAMKXNYpsk0TiJiwxmHMr6Xqvqt1kMo2wvAQR4+SteDlPJDESALhj0ii9AZ6bn4gJA6dAXpVRmfh8WTe+aZynbkmhXpEgiNYmLlGSQMIMuJsAqazGdFbRYBn25iWRqliG/R3aMCXQQikG3fNIZt7nzEZ+jQobVZAkoVyMZt7crRATouaskOvMsf02AnfYC1VYMetzvigDdjBiflAY9LxctCJUI3SJJNDMXF0D4oPtcXEQ7dbt4dhjzrIKjUqnUvF8H6BqDAq9gj7ctqYI90g9V6qMlJOtju9kx6MoHPYXzTgtxS7IAUGiTJNrOxYUQkqmX7HRlBvWEJmxxVUQZY1hslEFc4Lv/+R04YRcXkSRa8UlcYBg8QHMpQB1MFEWAbnsBetn0rlcjDwG61KDHWCxKyOqxiXrfu25gmdsfUEoG3Z94mwbaFSrqeAIalrikoUG3Crx9eXXpg58TbVQF6KFn3yBGoLBOAU7Td1hZMqpRkJVTAaDe3YqT0yJQbbdyYDPJoIcCdFVJlOW2UJEKVPNWSZRSnn8CEihQaKgk0ZX3NXKuZBrRuTXDYrWoA/QhQrTdoNjXZUOXy65GDIPuZBigyzNL47zTQtySLACYlidxiVr58BiX+MdbMao91qH/buEpnHfbBfjY/34uke+TDPhIyGaxRutwXIqiWcSTTzwJpiQuXINeKnAdY8NxPV22v9KjHVGsaGEOi4Y36GTp7S9RUx7oGTDoIqBhop0Rf4AuGXSpR0ihWBFjTN27cPCyUomLYtCTLJQQWr1RiaLhgFAEsG4xmkEHeH/KAFTlvtDKhOzichO4+Cdm+2a6+6oWgarVRnsvCY/wCq8pJjwO8psk2sq9JlM3MmmziGBbVRKXLgL0VvcaGJ5iRTpAHyKwiCTRxCqJyopiVshmUTDqdobshAzCo847ty4u0nUggkE3TAsmCMCiJz4qQC9kYLvXBj9+6n8BAI/M/jqR75NJnrvxazw2939qu9SNyyA77OJCCMGY0KFXfNVEZQCPRt1j0KUG3W6EJC71RM6hG6gqom0kLqkkiToyQOfPvOHToKtiJSpbM/kAnaqVMRKQrwErcDMJJ6oo7V/CEhcgvliRCNAdJXGJyD8RAWZVBpqhROXcaXP9E4guA/SWgWobJlkWdQuvSEoCJM82i63837MtVGR7Ehd/kqjZvcSlVWIsMNhuRX7oAH2IECX1SIoo8kr+5o9BVwN5H2nQZWGNQuh6AgBMCyWXAGBoRLjjOOKE4zo3IOXy7y0wU51N9PsWKw5co4brnv0KPnvvv3nbhW58XAbojaCLC+DJYgKJojJAr9c8Bl1q0F2KsuGqh6aRon1gp6g3RJJohwF6oismIvhyJX0Z5eLSrrR9N3++VfLcCiUuTAXoCUpc/EmigK+aUOiaCImLx6BHyNsEg14hJr/cjVCAnrf6Dv6Vk9kuGfRO7AZjYmyZ0xOWYJqG6WnQc3PRguikgmpmPuhC4hLJoHeRJNrqXvu3aw26xsBAssVRgWpXSaKMeQy6GWbQ+bKuHZHQ1CtEFSrKuwZdBn9Fcf0CME0UxXFHabllh15sWbgmG6vFmeq+RL+vXKFwrSoYXMw3Fr3tQpayamQc7373u2Epm0VvgB6P0qFLzWyjjknp4iIlLpRi0WQqEM3SOlSiUw26DOAl454IRIAug/AAgy416KrEYwoBeqvAZbna3LhKoonYLIq2Fw7Qwwy61KALpj1q9axgWABjqMp9TjhA56/5kbgkx6C3rqjZ+n4rDXpofOLBJAEFg5thtetWaMWgK6lHRi4ujpS4GH4GnV/jbhh0qiwWYxh0nSSqMWiIshuUWtGulopc1yuuEdagm9kz6J69ZP9o0Gsi+CsZUQy6iRLj59IqQI9zcQG84L3X1UT31pJl0MtVCmbUQQhBw3ctpCxlojiBibExwHXAa1J7Abr0Tq/EMOhNEhfqcIlLjhj0TjXoUqOfbIDOn2lppUiCHUtgXxouLrbotFppcztWLYTZ0yRtFuXkREpclAY9JkAviAA9QoMu2ckqMfkUKMSgL1t7nzb8Epw0A/Q2AZsj7q8V6k8JIapaM83B8xwFp0Ww2s5eMlU4Dl85J0GbRUP5oK/8mFolBAPe850bKVdK0AH6EEGOQX6/4kQYdJeq8tRGaFCRDLrTZdnfbkCjGHS5FJzT51tKV4pGoXmnYaLoEoAxNCJ00O30e4CnT+8lg84YS1ziUq5SMLMOQgDHpYq1WZABujmGz116Ka+5WCwGZqeyWFG5GhGg2w1ls1i2KwAA13GwZLiQTh9ODgb0Tm0WZQBfq6fAoItOJDBIKwY9vQC9FYPuPd/LZdDDPugJXC+/iws/OP4aF6CLQD7clwJA0SyAAagRLs2I06DnRk4dCND3dvdVLe63LF4UF7ApDXrEiqQJ+bvZP89RaOXKlWnROUpVkmiwUFECEpc2SaJ+q+BBhg7QhwjKZtFf8j4JqQelvqWuUHlqmSSapc1iBIOelP97WqgzwaCbpeadhoESE4xoRLEcT+LSwsXFSskXuwX21ecDAVM3S6AA75xrdRcwbXU/bTHISomLDLIBeC4aAh6DHp0kOlkMatCXaJULucTfitL/9xr1DgsVSQa9mgaDbjVLXIhi0FOUuLSUPPDXjplFtcyWggY9HKBLBr1J4sKfZSVxiXJwIhbAgJohGPRQgJ47ba5/YjY329XMgbbIOSgKwqEek/RORYAeXuEF4GPQ822zaBnx551J0TlqexarPomLkWCAHkcyyaT4uPs9KNAB+hDBSxKNClS7+GLHFn6ozYOKpRj07B6klhOTnD7fDTGhKZoRDDqAIvh1btSrTfts0Wm1krikVvq9BZ4qPxN4b3fJWJUrfNAtjnjfI6+bTBJtFaBPSA16bJKo1KBzNr4sJ0Oi7WQ56ZRQDHq7AF0y6Glo0I1miYtkf70APQWJSwtm0Vi2i4v8YNjFJYUAXVUTDdsshiQuMRp0BqBmGPxYQwF6Kn733cCfJMpcYH7lOSjKxSUiaFOSvRjCQQboBau5P5Xsb7f9UVqwO5qYZCNxoaR55VxOgrpxSGtVNRbwtfMszruH0AH6EMGNDFT5K+uGQlcVxUhzeWore4lL1MRErTLnVONSlxr0wmjk/pK4znXpMOL/XcmqdmKz2MOl0d+Xnw2875aBltKU4qj3Pbb4zgWRMLqmNIn1q1fzsKsYZtCFxKUSEaD7GHQZ7C9QLnXJZYDe4l4DHoOehsTFjZC4eIWK0nNxaSV5WGmOhefikqIG3TPtDn5OSlzENYvSoMvCb1VCIiUuills5KRfC0/M5lYuc2mVLOnVdYiprsyiK10D3nWmOahrEEawomYLiUsWTLJLIXtOM07issLnR47LVkwtj2JRrgDnZCKaEnSAPkRomSTaJYOuChYY4QCdMxaNPGjQ/RMT0dnlVOGimOBSYSRyf1F0iI1Gs8SlE1ZVubj0kIF4ujwdeN9tNVEZWFtFH4MuvnOuvgAAWDO2Bu894zRYQBODPjnOr+GiP0D3ubiMWaMghGDJroC6FGUq9f5icpOhM5FELVMGXfqgCwY94IOevgZdPteFCCnXsgszqQSdcICewPVSDIEZfA0z6EqDLgP0CImLYYIxoC6TREMFoLzckpwELuECVY2V1w5olfxeaMOoehr0eAad2tnXNQjDX1HTaCVxyUKD7jjKHCKQfyJdXIAVD7CtJt9ANhLNLNA3AfozzzyD97znPTj66KPxile8AnfccUdg/3XXXYcTTzwRRx55JN7xjndgeno65puGF60qiXYVqdqN2CRRU0hcKFv5bLpbRDLoRO7L5wNeF8FfsR2DbjdLXDoJ2ooZDOTPLu0OvG+kEqDzn+frnEGftMbxvw/8f5zpCQfoYxFJovIzjTpMw8S4xa//kl3BossHcDmpdXJQeVAySJ26uFTTYNBNyaD7pXNC4qKWqlJg0O34QXzZEq6mQkUJFkqQQb68FspmMfTd9bAGPWLiIZLG6/I4QwGvClyyCNiiEGL4u6nW2aq+gzchi75fDqTsLyJJVLqO5FDi0i5Zst15pwnXsdW4H/RBNwBCuvKWV6sGMRIXaSurGfQcYGZmBieccAKq1Sq++tWv4pOf/CT+8R//Ue3fsWMH3vrWt+Lcc8/Ff/zHf2BmZgavfe1r4eZVYJwRovzAZT/flc2i4/iyuYNNSvp428TNTPAdqUHPW0GPEGSAHs+gi5WJKAa9g6AtC4lLmDHvlkFfrPBrZBS972mEJC6rChPYce/9fHguBhNuZYC+uBTBoItgSXqhl+0lLLp822pzDABgZ7gqJFETUoZ2lURHU7RZVDKWKB/0XiSJttDmdsywxVYS7eoQOWRipOyAjBjZjwhmZfXVSDmG+N26YfBDjNOg5yVwkSsncuLbRZKoI341OkBv0Z+5rlenIypJVFxTOzyZyAHaJktmqMWmYpXXImYg/8QrVMRWPDFvf945m4imhAiT5fzhU5/6FA4++GBs375dbbvlllvUz5///Ofx53/+5zj33HMBANu3b8cBBxyAH//4x9i6dWvPjzevUAx6gElOQOphN3iSaBSDbpgAIbAJ+MMaNyVOEbQFg96NV2uakJKgUmk8cr/0R687zQx6J9UlsyhU5IQkId36iJdFgSFieQOr7dpgjKmiRTLABhDBoPNruBijQQfAvdCXuA59jvFtG4urMVeZzUWAXlc+6G006KnaLAoXl1YMeio+6PFJg8tu37EBegoSl7hCRWJS6LbRoDMGNJRtUTCoLCx3YpI25H0vjfJj7YIRcVr43reUNNkN7jJGiNLw+6EY9AjL2qzRrqJmoY32Pk3YTh2w0HRNZQxA5Zi/ArR3cRHJsUkSDjlEXwTot9xyC7Zt24ZzzjkH9913Hw499FBceOGF2LJlCwBg586deMtb3qI+v2HDBhxxxBG45557mgJ027bh+JiLSqUSeB1kVKsVULsG2y6o863VHFC7hkbdXPk1KC+i3nBADYJ6rY4K8b6HNihog2LJtlFZXABGowPONNGoV0HtGur1KioVUTiJMlC7BtchqFQq6l+g2EqGWGrUQSmFQ2PapsOdCRbKC037y0v8PjO3hkol2gWGUX5NFheXUKlEy2iSRq1aA607KBgWbNfBXHkelZGVP3ez+xZ5e3bKyiJtfnEBe8wZNKp1jFgjcOo2bNtGBQ4KlAG+a2USG9SuYd+847UBl4HYDrC4AFQqKNECaN3B7vk9mK6XQRnFWozzNt2oZ95vyHvtOjVUKvFtlzk1fr/LLLljXioDtoOq7YDCgV2z1Xc7tQZo3UGVOKjYDlBeDFz7JFAuL4l2Xmg6J2rze1upOJ2db60O2A4qtTqsSoW3AdsBlirdH3etyr+r0eDfRV3+vlwOfneZX88l2wGtO3DqzcfuNlzQho1Fh6JmO3AXgtfVFfe5spTgfe4GS0v8XInR9fWsVaugti368eDkRp730lLEOLa0iKWGDdqgsOt2035mM9AGxSKt5G4sWFjk7RgRbRwAGOXnXV6q9Px+L9RqoAYFGsG25tQaoLaLmu2gMj+PlQg15LPt0mL0ebnivMtLqFTGujiLIBhjPbn/1WpV/b12B5QJLrvsMvac5zwn9t973/te9dnVq1ez8fFxdsUVV7CHHnqIfeITn2ClUok98sgjjDHGDMNgN9xwQ+D7Tz75ZHbBBRc0/d2LL76YgS9c6n/6n/6n/+l/+p/+p//pf/pfz//t3bu3ZZxMGMtmjX9+fh779u2L3T8+Po6NGzcCAA444ABs2bIF1113ndp/7LHH4swzz8RHPvIRTE5O4oorrsCf/dmfqf3HHXcctm3bhn/4h38IfG+YQV9aWsLGjRsxMzODsbHkZmIa/YNqtYr169dj7969GB3tDZuskS/oNqCh24CGbgPDjV7df8YYarUa1qxZA8OIX2HITOKyevVqrF69uqPPHn300ZicnAxsm5ycVEsfL3zhC/Hggw+qAL1Wq+Gxxx7DUUcd1fRdhUIBhULzsv/Y2Jh+IIcco6Ojug0MOXQb0NBtQEO3geFGL+5/J4RwX7i4vP3tb8d3v/td/OpXvwIA3HHHHbj77rvx6le/GgDwtre9DVdeeSV+85vfgDGGz3zmMxgdHcVrXvOaLA9bQ0NDQ0NDQ0NDY9noiyTRc845B7t27cJxxx2HsbExOI6DSy+9FKeccgoA4Pzzz8cjjzyCF77whSiVSli3bh2uv/56jI/3PiFRQ0NDQ0NDQ0NDoxv0RYAOAB//+Mdx0UUXYW5uDvvtt18gw9YwDFx22WX4zGc+g4WFBUxNTXWcgWtZFi6++GJYVt9cCo2EoduAhm4DGroNaOg2MNzI2/3PLElUQ0NDQ0NDQ0NDQ6MZfaFB19DQ0NDQ0NDQ0BgW6ABdQ0NDQ0NDQ0NDI0fQAbqGhoaGhoaGhoZGjpAPJXyG+P73v4+HHnoImzZtwhvf+EYUi8WsD0kjITz88MO48cYbA9uOPPJInH766ep9rVbDDTfcgN///vc45phj8PKXvzzw+Xb7NfKFH/zgB9i5c6d6/3d/93dNn5mZmcENN9yApaUlbN26FS984QsT3a+RLf793/8dzzzzDABg06ZNOOeccwL7t2/fjunp6cC2t73tbTjwwAPV+1/96lfYsWMHSqUS3vCGN2D//fcPfL7dfo1sUalU8L3vfQ9PPfUUjjzySLzyla9sMo644447cO+992L//ffHG9/4xiZf6m73a2SLZ555BrfddhsqlQpe+tKX4g//8A/Vvt/+9re49tprA58/5JBDcPbZZ6v3juPgxhtvxP/93//hBS94AV796lcH2lC7/UlgqBn0t7/97XjHO96BRx99FJdccglOPPFEVKvVrA9LIyH84he/wOc//3nMzc2pf0tLS2p/uVzGy172MnzqU5/CI488grPPPhvnn39+x/s18odqtYq5uTn84he/wN///d837X/00Udx5JFH4tprr8W9996L448/HldeeWVi+zWyx+LiIubm5nDjjTfi8ssvb9r/hS98AXfeeWegX6CUqv3f+ta3cOyxx+Luu+/GDTfcgCOOOAL33Xdfx/s1ssWPf/xjvPjFL8Y3vvEN7Nq1C+9617tw8skno1arqc98+MMfxhlnnIFf/vKX+Jd/+Rds3rw5UNm82/0a2eKLX/wiTjrpJOzYsQM7d+7EKaecgg9+8INq/65du/CpT30q0AeUy2W1v9FoYOvWrbjwwguxa9cunHfeeXjzm9/c8f7EwIYUt99+OzNNkz322GOMMcbK5TI75JBD2Oc+97mMj0wjKVx11VXsmGOOid3/yU9+kh122GGsUqkwxhh7+OGHGSGE/fznP+9ov0Z+ccstt7Co7u0Nb3gDO+OMM9T77du3s8nJSVYulxPZr5EfXHTRRWzLli1N24855hh21VVXRf6Obdtsv/32Y5///OfVtne+853s5JNP7mi/RvZ44IEH2O7du9X7mZkZNjExwb75zW8yxhh76KGHGCGE7dy5kzHGWL1eZy960YvYhRdemMh+jezxk5/8hNVqNfX+tttuYwDYE088wRjj48NBBx0U+/v/9m//xqamptjc3BxjjLEnn3ySlUoldvPNN3e0PykMLYN+880344QTTsDznvc8AMD4+Di2bduGm2++OeMj00gS8/Pz+PKXv4wrr7wSv/zlLwP7br75ZpxxxhmqpO9RRx2F4447TrWBdvs1+guUUuzYsQNvfetb1bazzjoL1WoVP/3pT7ver9E/+OlPf4pLL70U119/fWDV9J577sHu3bsD9/itb30r7rjjDpTL5bb7NbLHi1/8YmzcuFG9X7t2LYrFIhqNBgDglltuweGHH47NmzcDAIrFIt785jerfr3b/RrZ46STTkKpVFLvp6amAEC1AYDLVy+//HJ85Stfwf333x/4/Ztvvhmvf/3rsXr1agDAwQcfjFNPPTUQG7TanxSGNkB/8sknccghhwS2bdq0CU8++WRGR6SRNI4++micddZZeOKJJ7Bjxw685CUvwSWXXKL2t2sDuo0MFnbv3o16vR64p6Ojo9iwYQOefPLJrvdr9AfOPfdcrFmzBr/97W/x8Y9/HIcffjh+/etfA+DPvLynEps2bQJjDE899VTb/Rr5w5e+9CUYhoHXve51ALrv9/W40H/4xCc+gZNOOkkRsoceeij+8i//Er/73e9w++23Y8uWLXj/+9+vPp+XNjC0SaKMsSZBPyEETNdtGhgce+yxOPbYY9X7H//4x9i6dSvOOussHHnkkW3bgG4jgwV53+Luabf7NfoD/oGYMYY3vvGN+NCHPoQbb7wx9pmXn223XyNfuPbaa/HRj34UN954o5pUddvv63Ghv/DBD34Q9913H26//Xa17fDDD8enP/1p9f6BBx7Acccdh7POOgtbtmzJTRsYWgb94IMPxtNPPx3Y9vTTT+Oggw7K6Ig00sapp56KsbExPPzwwwDatwHdRgYLGzduRLFYDNzTRqOBmZkZHHTQQV3v1+g/EELwute9Dg899BAA/sxXKhXMzc2pz8j7feCBB7bdr5EfbN++HX/1V3+Fm266CSeddJLa3m2/r8eF/gBjDOeffz6+973v4fbbb2/5fB5zzDHYtGlToB/IQxsY2gD9Va96Fe666y61LFmv1/Hd734Xf/Inf5LxkWkkBfmwSezcuRNLS0t4/vOfD4C3ge985zuwbRsA8Pjjj+Oee+5RbaDdfo3+QqFQwKmnnhqw1/rOd74Dy7Jw4okndr1fI//YvXs39uzZE9j2ox/9SPUJL3nJS7B27drAPf6v//ovHH/88Vi9enXb/Rr5wJe+9CX87d/+LXbs2IEtW7YE9r3qVa/Cww8/rIgaSim+/e1vB/r9bvZrZA9KKd72trfh7rvvjgzOw7HBr3/9azz99NOB2OB//ud/UKlUAAB79uzBj370o0AbaLU/KRA2xOsy27Ztw4MPPogzzzwTt99+OxYWFvCzn/0Mk5OTWR+aRgJ473vfi0ceeQQnnHACZmdncfXVV+Ptb387vvjFLwIA9u3bh+OPPx5TU1PYsmULrr32Wpxwwgm45pprOtqvkT88+OCDuOmmm/CrX/0K27dvxz/90z8BAN73vvdhfHwc999/P0466SS89rWvxYEHHoivfe1r+MQnPoG//uu/BoCu92tkj1tuuQUPPPAAduzYgccffxznn38+1q5di/POOw+//e1v8YY3vAHHH388DjroINxxxx144IEH8KMf/QjHHHMMAM68vve978W5556L+fl5XHfddfj+97+vAr12+zWyxTe/+U2cc845OOecc3D00Uer7Vu2bFFM+rve9S7ceuutOPvss7Fz5048/vjj+PnPf4799tsvkf0a2eI973kPvvKVr+Bv/uZvsGbNGrX9rLPOwh/8wR/g4osvxg9+8AOceOKJqFQquPrqq/Ga17wGV199NQBu17tlyxYYhoFXvepV+O///m8ccsghuPXWW0EIabs/KQx1gO66Lr797W/jwQcfxKZNm3D22WdjfHw868PSSBB33XUXfvKTn2B0dBRbtmxRmfcSCwsLuOaaa1Qhom3btgUesHb7NfKFe++9F9/61reatn/kIx/BxMQEAOCJJ57At771LSwtLeGVr3wl/viP/zjw2W73a2SL66+/Hj//+c8D2zZs2IAPf/jDALhP+vXXX48nnngChxxyCE4//fQm9vuee+7BLbfcglKphDPOOEMll3W6XyM73Hbbbbjtttuatm/dujXAcN5www249957MTU1hbPPPjsQyCWxXyM7fO1rX1OJ336ce+65OPzwwwHwseIHP/gBLMvCS1/60qZV0Gq1imuuuUYVIvrTP/1TWJbV8f4kMNQBuoaGhoaGhoaGhkbeMLQadA0NDQ0NDQ0NDY08QgfoGhoaGhoaGhoaGjmCDtA1NDQ0NDQ0NDQ0cgQdoGtoaGhoaGhoaGjkCDpA19DQ0NDQ0NDQ0MgRdICuoaGhoaGhoaGhkSPoAF1DQ0NDQ0NDQ0MjR9ABuoaGhoaGhoaGhkaOoAN0DQ0NDY1YnHzyyfjhD38Y2EYpxebNm5sqdmpoaGhoJAMdoGtoaGhoxOK+++7D7OxsYBtjDPfeey8WFhYyOioNDQ2NwYaV9QFoaGhoaPQ3Lr/8cnzta19r2n7XXXehWCxmcEQaGhoa/Q0doGtoaGhodIXTTjsNf/RHf6TeX3zxxVhYWIBl6SFGQ0NDYyXQvaeGhoaGRktccMEF+PSnPx27/8ADD8SBBx4IALjsssvw+OOP484774RhaBWlhoaGxkqgA3QNDQ0NjZY477zzsHXrVvWeUooTTjih6XPXX389PvOZz+CnP/0p1q1b18tD1NDQ0Bgo6ABdQ0NDQ6MlDj30UGzevFm9dxyn6TN33XUXzj//fNx666147nOf28Oj09DQ0Bg86PVHDQ0NDY2usGvXLpxxxhm46qqrcNxxx2V9OBoaGhp9Dx2ga2hoaGh0hYsvvhiVSgUXXXQRNm/erP41Go2sD01DQ0OjL0EYYyzrg9DQ0NDQyCd+8Ytf4LnPfS7Wrl0b2H7PPffgiCOOwOTkJB5//PEmr3QAeMlLXgJCSK8OVUNDQ2NgoAN0DQ0NDQ0NDQ0NjRxBS1w0NDQ0NDQ0NDQ0cgQdoGtoaGhoaGhoaGjkCDpA19DQ0NDQ0NDQ0MgRdICuoaGhoaGhoaGhkSPoAF1DQ0NDQ0NDQ0MjR9ABuoaGhoaGhoaGhkaOoAN0DQ0NDQ0NDQ0NjRxBB+gaGhoaGhoaGhoaOYIO0DU0NDQ0NDQ0NDRyBB2ga2hoaGhoaGhoaOQIOkDX0NDQ0NDQ0NDQyBH+fwoOrYPckRtjAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "formant off: energy 800–1150 Hz / 1200–1600 Hz = 0.05\n", + "formant on : energy 800–1150 Hz / 1200–1600 Hz = 730.42\n" + ] + } + ], + "source": [ + "def formant_voice(f0=240.0, center=960.0, seconds=1.5):\n", + " t = np.arange(int(seconds * sr))\n", + " x = sum((np.exp(-(((f0 * h) - center) / 180.0) ** 2) + 0.05)\n", + " * np.sin(2 * np.pi * f0 * h * t / sr) for h in range(1, 17))\n", + " return x / np.abs(x).max()\n", + "\n", + "def spectrum_db(x, n=8192):\n", + " X = np.abs(np.fft.rfft(x[-n:] * np.hanning(n)))\n", + " return np.fft.rfftfreq(n, 1 / sr), 20 * np.log10(np.maximum(X / X.max(), 1e-6))\n", + "\n", + "src = formant_voice()\n", + "outs = {}\n", + "for formant in (False, True):\n", + " c = tap.Tune(sr, speed=0.0, mode=\"midi\", backend=\"pvoc\", formant=formant)\n", + " c.note_on(64) # E4\n", + " outs[formant] = c.process(src)\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 3.6))\n", + "for x_, name, color in [(src, \"source: f0 240 Hz, formant 960 Hz\", C[0]),\n", + " (outs[False], \"corrected to E4, formant off → bump follows the shift\", C[2]),\n", + " (outs[True], \"corrected to E4, formant on → bump stays near 960\", C[4])]:\n", + " f, S = spectrum_db(x_)\n", + " ax.plot(f, S, color=color, alpha=0.9, label=name)\n", + "ax.axvline(960, color=\"gray\", lw=0.8, ls=\"--\")\n", + "ax.set(xlim=(0, 2600), ylim=(-60, 3), xlabel=\"Hz\", ylabel=\"dB (norm.)\",\n", + " title=\"a 5.5-semitone MIDI-mode correction, with and without formant preservation\")\n", + "ax.legend(loc=\"upper right\", fontsize=8)\n", + "plt.show()\n", + "\n", + "def band(x_, lo, hi, n=8192):\n", + " X = np.abs(np.fft.rfft(x_[-n:] * np.hanning(n))) ** 2\n", + " f = np.fft.rfftfreq(n, 1 / sr)\n", + " return X[(f >= lo) & (f <= hi)].sum()\n", + "\n", + "for formant, y in outs.items():\n", + " label = \"formant on \" if formant else \"formant off\"\n", + " print(f\"{label}: energy 800–1150 Hz / 1200–1600 Hz = {band(y, 800, 1150) / band(y, 1200, 1600):7.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "27a42a4e", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "- **Retune speed** is the character control: 0 ms = the hard-snap effect, tens of ms =\n", + " transparent correction, hundreds of ms = drift repair only.\n", + "- The **three backends** share detection, mapping, and glide, and all land the same intonation;\n", + " choose by material and latency budget — `grain` (default, cheapest, waveform-preserving),\n", + " `psola` (voice, formant-preserving), `pvoc` (dense material, plus the `formant` option for\n", + " large corrections).\n", + "- Every figure above is the shipping `tune.h` kernel driven through `tools/capi`; the hard\n", + " gates live in `tests/tune_test.cpp` (kernel) and the DspTap primitive batteries." + ] + } + ], + "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/submodules/dsptap b/submodules/dsptap index 9cbfbca..b3e9ee5 160000 --- a/submodules/dsptap +++ b/submodules/dsptap @@ -1 +1 @@ -Subproject commit 9cbfbca6670bdc929bab2804c713b60dad8b1c0a +Subproject commit b3e9ee53b4cff54ad53d4d607a61b02ae3aba3ee diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index ea97a18..4b25c4f 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -18,6 +18,7 @@ add_executable(taptools_kernel_tests nr_test.cpp spectra_test.cpp step_seq_test.cpp + tune_test.cpp tr808_clap_test.cpp tr808_cymbal_test.cpp tr808_hat_test.cpp diff --git a/tests/tune_test.cpp b/tests/tune_test.cpp new file mode 100644 index 0000000..26ba100 --- /dev/null +++ b/tests/tune_test.cpp @@ -0,0 +1,333 @@ +/// @file +/// @brief Unit tests for the pitch-correction kernel (tap::tools::tune::corrector). +/// @details Drives the full chain — YIN detection, scale/MIDI target mapping, retune glide, +/// period-locked resynthesis — with synthesized tones and measures the output pitch +/// using the DspTap YIN primitive (certified by DspTap's own test battery) as the +/// oracle. Checks chromatic snapping, scale masks, per-note enables, MIDI targeting, +/// retune speed, correction amount, unpitched relaxation, and amplitude sanity. +// SPDX-License-Identifier: BSD-3-Clause +// Copyright 2026 Timothy Place. + +#include +#include +#include + +#include +#include + +namespace { + + constexpr double k_pi = 3.14159265358979323846; + constexpr double k_sr = 48000.0; + + double sine(int t, double f) { + return std::sin(2.0 * k_pi * f * t / k_sr); + } + + /// Run `seconds` of a sine through the corrector and return the output tail. + std::vector run_sine(tap::tools::tune::corrector& c, double freq, double seconds) { + const int n = static_cast(seconds * k_sr); + std::vector out(static_cast(n)); + for (int t = 0; t < n; ++t) { + out[static_cast(t)] = c.process(sine(t, freq)); + } + return out; + } + + /// Measure the fundamental of the last stretch of a signal with the DspTap detector. + double measure_hz(const std::vector& x) { + 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() >= det.frame_size()); + const auto r = det.analyze(x.data() + (x.size() - det.frame_size())); + REQUIRE(r.voiced()); + return k_sr / r.period; + } + + double cents(double f, double ref) { + return 1200.0 * std::log2(f / ref); + } + +} // namespace + +SCENARIO("chromatic hard snap retunes a sharp note to the nearest semitone") { + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_speed(0.0); // hard snap + + const auto out = run_sine(c, 452.0, 1.0); // 46.7 cents sharp of A4 + REQUIRE(std::abs(cents(measure_hz(out), 440.0)) < 5.0); + REQUIRE(std::abs(c.detected_hz() - 452.0) < 2.0); + REQUIRE(c.target_midi() == 69.0); +} + +SCENARIO("the scale mask steers the target to an enabled note") { + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_speed(0.0); + c.set_key(0); // C + c.set_scale(tap::tools::tune::k_scale_major); + + // 460 Hz sits closest to A#4 (466.16), which C major disables; the nearest + // enabled note is A4. + const auto out = run_sine(c, 460.0, 1.0); + REQUIRE(std::abs(cents(measure_hz(out), 440.0)) < 5.0); +} + +SCENARIO("per-note enables edit the effective mask") { + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_speed(0.0); + c.note_enable(9, false); // remove A from the chromatic mask + + // With A gone, 452 Hz snaps up to A#4 instead. + const auto out = run_sine(c, 452.0, 1.0); + REQUIRE(std::abs(cents(measure_hz(out), 466.16)) < 5.0); +} + +SCENARIO("midi mode targets the nearest held note, and no held notes means no correction") { + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_speed(0.0); + c.set_mode(tap::tools::tune::mode::midi); + + WHEN("a note is held") { + c.note_on(64); // E4, 329.63 Hz + const auto out = run_sine(c, 350.0, 1.0); + REQUIRE(std::abs(cents(measure_hz(out), 329.63)) < 5.0); + REQUIRE(c.target_midi() == 64.0); + } + + WHEN("no note is held") { + const auto out = run_sine(c, 350.0, 1.0); + REQUIRE(std::abs(cents(measure_hz(out), 350.0)) < 5.0); + REQUIRE(c.applied_semitones() == 0.0); + } +} + +SCENARIO("retune speed sets the glide onto the target") { + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_speed(100.0); + + // 452 -> A4 is -0.467 st. With a 100 ms time constant the glide should be + // essentially complete (10 taus) after a second, but must still be in + // motion shortly after detection first lands. + double early = 0.0; + for (int t = 0; t < static_cast(0.1 * k_sr); ++t) { + c.process(sine(t, 452.0)); + } + early = c.applied_semitones(); + + for (int t = static_cast(0.1 * k_sr); t < static_cast(1.5 * k_sr); ++t) { + c.process(sine(t, 452.0)); + } + const double full = c.applied_semitones(); + + REQUIRE(std::abs(full - (-0.467)) < 0.03); + REQUIRE(std::abs(early) > 0.0); + REQUIRE(std::abs(early) < std::abs(full) * 0.95); +} + +SCENARIO("amount scales the correction depth") { + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_speed(0.0); + c.set_amount(50.0); + + // Half of the -46.7 cent correction: expect the output about 23 cents + // above A4. + const auto out = run_sine(c, 452.0, 1.0); + const double measured = cents(measure_hz(out), 440.0); + REQUIRE(std::abs(measured - 23.3) < 5.0); +} + +SCENARIO("unpitched input relaxes to no correction and stays finite") { + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_speed(10.0); + + std::mt19937 gen(42); + std::uniform_real_distribution dist(-1.0, 1.0); + + double peak = 0.0; + for (int t = 0; t < static_cast(1.0 * k_sr); ++t) { + const double y = c.process(dist(gen)); + REQUIRE(std::isfinite(y)); + peak = std::max(peak, std::abs(y)); + } + REQUIRE(c.detected_hz() == 0.0); + REQUIRE(std::abs(c.applied_semitones()) < 1e-3); + REQUIRE(peak > 0.1); + REQUIRE(peak < 2.0); +} + +SCENARIO("voiced amplitude survives the two-tap resynthesis") { + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_speed(0.0); + + const auto out = run_sine(c, 452.0, 1.0); + double peak = 0.0; + for (size_t i = out.size() - 4800; i < out.size(); ++i) { + peak = std::max(peak, std::abs(out[i])); + } + REQUIRE(peak > 0.8); + REQUIRE(peak < 1.2); +} + +SCENARIO("processing before prepare passes the input through") { + tap::tools::tune::corrector c; + REQUIRE(c.process(0.25) == 0.25); + REQUIRE_FALSE(c.prepared()); +} + +namespace { + + /// Band-limited sawtooth normalized to peak 1 — harmonic-rich material every + /// backend handles (PSOLA resamples the spectral envelope, so it needs + /// harmonics; see tap/dsp/psola.h). + std::vector run_saw(tap::tools::tune::corrector& c, double freq, double seconds) { + const int n = static_cast(seconds * k_sr); + std::vector wave(static_cast(n), 0.0); + double peak = 0.0; + for (int t = 0; t < n; ++t) { + for (int h = 1; h <= 12; ++h) { + wave[static_cast(t)] += std::sin(2.0 * k_pi * freq * h * t / k_sr) / h; + } + peak = std::max(peak, std::abs(wave[static_cast(t)])); + } + std::vector out(static_cast(n)); + for (int t = 0; t < n; ++t) { + out[static_cast(t)] = c.process(wave[static_cast(t)] / peak); + } + return out; + } + +} // namespace + +SCENARIO("every resynthesis backend snaps a sharp note onto the target") { + using tap::tools::tune::backend; + + for (const auto b : {backend::grain, backend::psola, backend::pvoc}) { + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_speed(0.0); + c.set_backend(b); + REQUIRE(c.resynth_backend() == b); + + // 226 Hz saw: 46.4 cents sharp of A3 (110 * 2 = 220). Voice-like input so + // the comparison is fair to all three engines. + const auto out = run_saw(c, 226.0, 1.5); + REQUIRE(std::abs(cents(measure_hz(out), 220.0)) < 6.0); + + double peak = 0.0; + for (size_t i = out.size() - 4800; i < out.size(); ++i) { + peak = std::max(peak, std::abs(out[i])); + } + REQUIRE(peak > 0.4); + REQUIRE(peak < 2.0); + } +} + +namespace { + + /// Play a melody of MIDI notes as 150 ms sawtooth segments through the corrector. + void play_melody(tap::tools::tune::corrector& c, std::initializer_list notes) { + const int seg = static_cast(0.15 * k_sr); + for (const int note : notes) { + const double freq = 440.0 * std::exp2((note - 69) / 12.0); + for (int t = 0; t < seg; ++t) { + double x = 0.0; + for (int h = 1; h <= 8; ++h) { + x += std::sin(2.0 * k_pi * freq * h * t / k_sr) / h; + } + c.process(x * 0.5); + } + } + } + +} // namespace + +SCENARIO("auto-key detection learns the key from a melody") { + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_autokey(true); + + WHEN("nothing has been heard yet") { + THEN("no estimate is offered") { + REQUIRE_FALSE(c.autokey_estimate().valid()); + } + } + + WHEN("a D major scale is played, tonic emphasized") { + play_melody(c, {62, 64, 66, 67, 69, 71, 73, 74, 62, 69, 62}); + + const auto e = c.autokey_estimate(); + THEN("the estimate is D major with healthy confidence") { + REQUIRE(e.valid()); + REQUIRE(e.key == 2); + REQUIRE_FALSE(e.minor); + REQUIRE(e.confidence > 0.5); + } + THEN("applying it sets the corrector's key and scale") { + REQUIRE(c.autokey_apply()); + REQUIRE(c.key() == 2); + REQUIRE(c.scale() == tap::tools::tune::k_scale_major); + } + } + + WHEN("an A harmonic-minor melody is played, tonic emphasized") { + play_melody(c, {57, 59, 60, 62, 64, 65, 68, 69, 57, 64, 57}); + + const auto e = c.autokey_estimate(); + THEN("the estimate is A minor") { + REQUIRE(e.valid()); + REQUIRE(e.key == 9); + REQUIRE(e.minor); + } + } + + WHEN("the learner is reset") { + play_melody(c, {62, 64, 66}); + c.autokey_reset(); + THEN("the estimate is withdrawn") { + REQUIRE_FALSE(c.autokey_estimate().valid()); + } + } +} + +SCENARIO("formant preservation on the pvoc backend still lands the correction") { + using tap::tools::tune::backend; + + tap::tools::tune::corrector c; + c.set_formant(true); // set before prepare — must survive into the pvoc + c.prepare(k_sr); + c.set_speed(0.0); + c.set_backend(backend::pvoc); + REQUIRE(c.formant()); + + const auto out = run_saw(c, 226.0, 1.5); + REQUIRE(std::abs(cents(measure_hz(out), 220.0)) < 6.0); +} + +SCENARIO("switching backends while running stays finite and keeps correcting") { + using tap::tools::tune::backend; + + tap::tools::tune::corrector c; + c.prepare(k_sr); + c.set_speed(0.0); + + const backend sequence[] = {backend::grain, backend::pvoc, backend::psola, backend::grain}; + int seg = 0; + for (const auto b : sequence) { + c.set_backend(b); + for (int t = seg * 12000; t < (seg + 1) * 12000; ++t) { + const double y = c.process(std::sin(2.0 * k_pi * 452.0 * t / k_sr)); + REQUIRE(std::isfinite(y)); + } + ++seg; + } + REQUIRE(std::abs(c.applied_semitones() - (-0.467)) < 0.03); +} diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index 4cfe6de..325d3ac 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include using tap::tools::conv_engine; @@ -633,4 +634,157 @@ int taptools_kick_process(taptools_kick h, const double* trig, double* out, int }); } +// ---- tap.tune~ --------------------------------------------------------------------------------- + +using tune_corrector = tap::tools::tune::corrector; + +taptools_tune taptools_tune_create(void) { + return static_cast(new tune_corrector()); +} + +void taptools_tune_destroy(taptools_tune h) { + delete static_cast(h); +} + +int taptools_tune_prepare(taptools_tune h, double sr) { + return with(h, [&](tune_corrector& c) { c.prepare(sr); }); +} + +int taptools_tune_clear(taptools_tune h) { + return with(h, [&](tune_corrector& c) { c.clear(); }); +} + +int taptools_tune_set_key(taptools_tune h, int pitch_class) { + return with(h, [&](tune_corrector& c) { c.set_key(pitch_class); }); +} + +int taptools_tune_set_scale(taptools_tune h, unsigned mask) { + return with(h, [&](tune_corrector& c) { c.set_scale(mask); }); +} + +int taptools_tune_set_notes(taptools_tune h, unsigned absolute_mask) { + return with(h, [&](tune_corrector& c) { c.set_notes(absolute_mask); }); +} + +int taptools_tune_set_mode(taptools_tune h, int mode) { + return with(h, [&](tune_corrector& c) { c.set_mode(static_cast(mode)); }); +} + +int taptools_tune_set_backend(taptools_tune h, int backend) { + return with( + h, [&](tune_corrector& c) { c.set_backend(static_cast(backend)); }); +} + +int taptools_tune_set_speed(taptools_tune h, double ms) { + return with(h, [&](tune_corrector& c) { c.set_speed(ms); }); +} + +int taptools_tune_set_amount(taptools_tune h, double pct) { + return with(h, [&](tune_corrector& c) { c.set_amount(pct); }); +} + +int taptools_tune_set_range(taptools_tune h, double min_hz, double max_hz) { + return with(h, [&](tune_corrector& c) { c.set_range(min_hz, max_hz); }); +} + +int taptools_tune_set_threshold(taptools_tune h, double t) { + return with(h, [&](tune_corrector& c) { c.set_threshold(t); }); +} + +int taptools_tune_set_formant(taptools_tune h, int on) { + return with(h, [&](tune_corrector& c) { c.set_formant(on != 0); }); +} + +int taptools_tune_set_autokey(taptools_tune h, int on) { + return with(h, [&](tune_corrector& c) { c.set_autokey(on != 0); }); +} + +int taptools_tune_autokey_reset(taptools_tune h) { + return with(h, [&](tune_corrector& c) { c.autokey_reset(); }); +} + +int taptools_tune_autokey_estimate(taptools_tune h, int* key, int* minor, double* confidence) { + if (!h || !key || !minor || !confidence) { + return -1; + } + const auto e = static_cast(h)->autokey_estimate(); + *key = e.key; + *minor = e.minor ? 1 : 0; + *confidence = e.confidence; + return 0; +} + +int taptools_tune_autokey_apply(taptools_tune h) { + if (!h) { + return -1; + } + return static_cast(h)->autokey_apply() ? 1 : 0; +} + +int taptools_tune_note_on(taptools_tune h, int note) { + return with(h, [&](tune_corrector& c) { c.note_on(note); }); +} + +int taptools_tune_note_off(taptools_tune h, int note) { + return with(h, [&](tune_corrector& c) { c.note_off(note); }); +} + +int taptools_tune_notes_off(taptools_tune h) { + return with(h, [&](tune_corrector& c) { c.notes_off(); }); +} + +double taptools_tune_detected_hz(taptools_tune h) { + return h ? static_cast(h)->detected_hz() : -1.0; +} + +double taptools_tune_target_midi(taptools_tune h) { + return h ? static_cast(h)->target_midi() : -1.0; +} + +double taptools_tune_applied_semitones(taptools_tune h) { + return h ? static_cast(h)->applied_semitones() : 0.0; +} + +int taptools_tune_process(taptools_tune h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](tune_corrector& c) { + for (int i = 0; i < n; ++i) { + out[i] = c.process(in[i]); + } + }); +} + +// ---- pitch detector passthrough ---------------------------------------------------------------- + +taptools_yin taptools_yin_create(int window, int tau_min, int tau_max) { + if (tau_min < 2 || tau_min >= tau_max || window < tau_max) { + return nullptr; + } + return static_cast( + new tap::dsp::yin(static_cast(window), static_cast(tau_min), static_cast(tau_max))); +} + +void taptools_yin_destroy(taptools_yin h) { + delete static_cast(h); +} + +int taptools_yin_frame_size(taptools_yin h) { + return h ? static_cast(static_cast(h)->frame_size()) : -1; +} + +int taptools_yin_track(taptools_yin h, const double* x, int n, int hop, double* periods, int max_out) { + if (!h || !x || !periods || hop < 1) { + return -1; + } + auto* det = static_cast(h); + const int frame = static_cast(det->frame_size()); + int count = 0; + for (int start = 0; start + frame <= n && count < max_out; start += hop) { + periods[count++] = det->analyze(x + start).period; + } + return count; +} + } // extern "C" diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index 8ba7b41..af2eeb6 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -219,6 +219,50 @@ TAPTOOLS_API int taptools_kick_reset(taptools_kick h); /// fire the voice with the edge value as accent — exactly the tap.808.kick~ wrapper's edge logic. TAPTOOLS_API int taptools_kick_process(taptools_kick h, const double* trig, double* out, int n); +// ---- tap.tune~ (tap::tools::tune::corrector) ----------------------------------------------------- + +typedef void* taptools_tune; + +TAPTOOLS_API taptools_tune taptools_tune_create(void); +TAPTOOLS_API void taptools_tune_destroy(taptools_tune h); +TAPTOOLS_API int taptools_tune_prepare(taptools_tune h, double sr); +TAPTOOLS_API int taptools_tune_clear(taptools_tune h); +TAPTOOLS_API int taptools_tune_set_key(taptools_tune h, int pitch_class); +TAPTOOLS_API int taptools_tune_set_scale(taptools_tune h, unsigned mask); // relative to key +TAPTOOLS_API int taptools_tune_set_notes(taptools_tune h, unsigned absolute_mask); +TAPTOOLS_API int taptools_tune_set_mode(taptools_tune h, int mode); // tune::mode +TAPTOOLS_API int taptools_tune_set_backend(taptools_tune h, int backend); // tune::backend +TAPTOOLS_API int taptools_tune_set_speed(taptools_tune h, double ms); +TAPTOOLS_API int taptools_tune_set_amount(taptools_tune h, double pct); +TAPTOOLS_API int taptools_tune_set_range(taptools_tune h, double min_hz, double max_hz); +TAPTOOLS_API int taptools_tune_set_threshold(taptools_tune h, double t); +TAPTOOLS_API int taptools_tune_set_formant(taptools_tune h, int on); +TAPTOOLS_API int taptools_tune_set_autokey(taptools_tune h, int on); +TAPTOOLS_API int taptools_tune_autokey_reset(taptools_tune h); +/// Current auto-key estimate: writes key (0-11, or -1 if none yet), minor (0/1), and the +/// profile-correlation confidence. Returns 0, or -1 on a bad handle. +TAPTOOLS_API int taptools_tune_autokey_estimate(taptools_tune h, int* key, int* minor, double* confidence); +/// Adopt the current estimate as key + scale. Returns 1 if applied, 0 if no estimate yet, -1 on error. +TAPTOOLS_API int taptools_tune_autokey_apply(taptools_tune h); +TAPTOOLS_API int taptools_tune_note_on(taptools_tune h, int note); +TAPTOOLS_API int taptools_tune_note_off(taptools_tune h, int note); +TAPTOOLS_API int taptools_tune_notes_off(taptools_tune h); +TAPTOOLS_API double taptools_tune_detected_hz(taptools_tune h); +TAPTOOLS_API double taptools_tune_target_midi(taptools_tune h); +TAPTOOLS_API double taptools_tune_applied_semitones(taptools_tune h); +TAPTOOLS_API int taptools_tune_process(taptools_tune h, const double* in, double* out, int n); + +// ---- pitch detector passthrough (tap::dsp::yin, for the notebooks' pitch tracking) --------------- + +typedef void* taptools_yin; + +TAPTOOLS_API taptools_yin taptools_yin_create(int window, int tau_min, int tau_max); +TAPTOOLS_API void taptools_yin_destroy(taptools_yin h); +TAPTOOLS_API int taptools_yin_frame_size(taptools_yin h); +/// Analyze every `hop` samples across x; writes up to max_out fractional periods in samples +/// (0 where unvoiced). Returns the number written, or -1 on error. +TAPTOOLS_API int taptools_yin_track(taptools_yin h, const double* x, int n, int hop, double* periods, int max_out); + #ifdef __cplusplus } #endif