[AT3P] Add experimental wideband GHA encodingwideband-gha-integration_2

Detect tonal components in full-band PCM, project them into PQF subbands using calibrated responses, and refine their parameters against real subband PCM. Preserve sparse bands, onset/offset envelopes, stereo fairness, and the shared 48-tone budget.

Add an optional raw-domain refit mode, calibration tooling, and normalized-amplitude regression coverage.

The feature is experimental and disabled by default. The previous per-subband GHA path remains the default; enable wideband analysis with GHA_WIDEBAND (--advanced=ghadbg=15).

7 files changed, 8336 insertions, 120 deletions

diff --git a/src/atrac/at3p/at3p.cpp b/src/atrac/at3p/at3p.cpp
index 9b32ffa..97fbe04 100644
--- a/src/atrac/at3p/at3p.cpp
+++ b/src/atrac/at3p/at3p.cpp
@@ -39,7 +39,7 @@ public:
     TImpl(ICompressedOutput* out, int channels, TSettings settings)
         : BitStream(out, 2048)
         , ChannelCtx(channels)
-        , GhaProcessor(MakeGhaProcessor0(channels == 2))
+        , GhaProcessor(MakeGhaProcessor0(channels == 2, settings.UseGha & TSettings::GHA_WIDEBAND, settings.WidebandRefineMode))
         , Settings(settings)
     {
         delay.NumToneBands = 0;
@@ -64,6 +64,15 @@ private:
         float Buf1[TAt3PEnc::NumSamples] = {0};
         float Buf2[TAt3PEnc::NumSamples] = {0};
         float PrevBuf[TAt3PEnc::NumSamples] = {0};
+
+        // Raw (pre-PQF) PCM, mirroring the Buf1/Buf2/CurBuf/NextBuf look-ahead
+        // scheme exactly so RawCurBuf always holds the same logical frame as
+        // CurBuf (PQF domain) at DoAnalize-call time. Needed by the wideband
+        // GHA path, which analyzes the original signal directly.
+        float* RawNextBuf = RawBuf1;
+        float* RawCurBuf = nullptr;
+        float RawBuf1[TAt3PEnc::NumSamples] = {0};
+        float RawBuf2[TAt3PEnc::NumSamples] = {0};
         TAt3pMDCT::THistBuf MdctBuf = {{{0}}};
         std::vector<float> Specs;
     };
@@ -82,7 +91,7 @@ EncodeFrame(const float* data, int channels)
 {
     int needMore = 0;
     for (int ch = 0; ch < channels; ch++) {
-        float src[TAt3PEnc::NumSamples];
+        float* src = ChannelCtx[ch].RawNextBuf;
         for (size_t i = 0; i < NumSamples; ++i) {
             src[i] = data[i * channels  + ch];
         }
@@ -92,6 +101,10 @@ EncodeFrame(const float* data, int channels)
             assert(ChannelCtx[ch].NextBuf == ChannelCtx[ch].Buf1);
             ChannelCtx[ch].CurBuf = ChannelCtx[ch].Buf2;
             std::swap(ChannelCtx[ch].NextBuf, ChannelCtx[ch].CurBuf);
+
+            assert(ChannelCtx[ch].RawNextBuf == ChannelCtx[ch].RawBuf1);
+            ChannelCtx[ch].RawCurBuf = ChannelCtx[ch].RawBuf2;
+            std::swap(ChannelCtx[ch].RawNextBuf, ChannelCtx[ch].RawCurBuf);
             needMore++;
         }
     }
@@ -109,13 +122,15 @@ EncodeFrame(const float* data, int channels)
     const float* b2Cur = (channels == 2) ? ChannelCtx[1].CurBuf : nullptr;
     const float* b2Next = (channels == 2) ? ChannelCtx[1].NextBuf : nullptr;
 
+    const float* raw1Cur = ChannelCtx[0].RawCurBuf;
+    const float* raw2Cur = (channels == 2) ? ChannelCtx[1].RawCurBuf : nullptr;
 
     const TAt3PGhaData* p = nullptr;
     if (delay.NumToneBands) {
         p = &delay;
     }
 
-    const TAt3PGhaData* tonalBlock = GhaProcessor->DoAnalize({b1Cur, b1Next}, {b2Cur, b2Next}, b1Prev, b2Prev);
+    const TAt3PGhaData* tonalBlock = GhaProcessor->DoAnalize({b1Cur, b1Next}, {b2Cur, b2Next}, b1Prev, b2Prev, raw1Cur, raw2Cur);
 
     std::vector<TAt3PBitStream::TSingleChannelElement> sces;
     sces.resize(channels);
@@ -153,6 +168,7 @@ EncodeFrame(const float* data, int channels)
             memset(ChannelCtx[ch].PrevBuf, 0, sizeof(float) * TAt3PEnc::NumSamples);
         }
         std::swap(ChannelCtx[ch].NextBuf, ChannelCtx[ch].CurBuf);
+        std::swap(ChannelCtx[ch].RawNextBuf, ChannelCtx[ch].RawCurBuf);
     }
     if (tonalBlock && (Settings.UseGha & TSettings::GHA_WRITE_TONAL)) {
         delay = *tonalBlock;
@@ -178,7 +194,7 @@ TPCMEngine::TProcessLambda TAt3PEnc::GetLambda() {
 
 static void SetGha(const std::string& str, TAt3PEnc::TSettings& settings) {
     int mask = std::stoi(str);
-    if (mask > 7 || mask < 0) {
+    if (mask > 15 || mask < 0) {
         throw std::runtime_error("invalud value of GHA processing mask");
     }
 
@@ -188,16 +204,28 @@ static void SetGha(const std::string& str, TAt3PEnc::TSettings& settings) {
         std::cerr << "GHA_WRITE_RESIUDAL" << std::endl;
     if (mask & TAt3PEnc::TSettings::GHA_WRITE_TONAL)
         std::cerr << "GHA_WRITE_TONAL" << std::endl;
+    if (mask & TAt3PEnc::TSettings::GHA_WIDEBAND)
+        std::cerr << "GHA_WIDEBAND" << std::endl;
 
     settings.UseGha = mask;
 }
 
+static void SetWidebandRefine(const std::string& str, TAt3PEnc::TSettings& settings) {
+    int mode = std::stoi(str);
+    if (mode < 0 || mode > 1) {
+        throw std::runtime_error("invalid ghawbrefine value (expected 0=subband or 1=raw)");
+    }
+    settings.WidebandRefineMode = (uint8_t)mode;
+    std::cerr << "GHA_WIDEBAND_REFINE=" << (mode == 1 ? "raw" : "subband") << std::endl;
+}
+
 
 
 void TAt3PEnc::ParseAdvancedOpt(const char* opt, TSettings& settings) {
     typedef void (*processFn)(const std::string& str, TSettings& settings);
     static std::unordered_map<std::string, processFn> keys {
-        {"ghadbg", &SetGha}
+        {"ghadbg", &SetGha},
+        {"ghawbrefine", &SetWidebandRefine}
     };
 
     if (opt == nullptr)
diff --git a/src/atrac/at3p/at3p_gha.cpp b/src/atrac/at3p/at3p_gha.cpp
index dd06ca2..0cef2d1 100644
--- a/src/atrac/at3p/at3p_gha.cpp
+++ b/src/atrac/at3p/at3p_gha.cpp
@@ -17,6 +17,7 @@
  */
 
 #include "at3p_gha.h"
+#include "at3p_pqf_wideband_table.h"
 #include "ff/atrac3plus.h"
 
 #include <util.h>
@@ -26,10 +27,13 @@
 #include <memory>
 
 #include <algorithm>
+#include <array>
 #include <cstring>
 #include <cmath>
 #include <iostream>
 #include <map>
+#include <optional>
+#include <utility>
 #include <vector>
 
 using std::map;
@@ -58,7 +62,155 @@ uint32_t PhaseIndexToOffset(uint32_t ind)
     return (ind & 0x1F) << 6;
 }
 
-class TGhaProcessor : public IGhaProcessor {
+constexpr double kWidebandFs = 44100.0;
+constexpr double kWidebandSubbandBw = kWidebandFs / 32.0; // 1378.125 Hz
+
+double LerpAngleWideband(double a, double b, double t)
+{
+    double d = std::fmod(b - a + M_PI, 2 * M_PI);
+    if (d < 0) d += 2 * M_PI;
+    d -= M_PI;
+    double r = a + d * t;
+    while (r < 0) r += 2 * M_PI;
+    while (r >= 2 * M_PI) r -= 2 * M_PI;
+    return r;
+}
+
+struct TWidebandResponse {
+    double Magnitude, Phase, Omega;
+};
+
+// Binary search + linear interpolation over the non-uniform calibration
+// grid emitted by tools/pqf_wideband_calibrate.cpp (see
+// at3p_pqf_wideband_table.h). Empirically measured by probing the real PQF
+// analysis filter with synthetic sinusoids -- not hand-derived from the
+// DCT-IV fold in atrac3plus_pqf.c.
+TWidebandResponse LookupWidebandResponse(int sb, double freqHz)
+{
+    const TPqfWidebandPoint* t = PqfWidebandTables[sb];
+    const size_t n = PqfWidebandTableSize;
+    if (freqHz <= t[0].FreqHz) {
+        return {t[0].Magnitude, t[0].Phase, t[0].Omega};
+    }
+    if (freqHz >= t[n - 1].FreqHz) {
+        return {t[n - 1].Magnitude, t[n - 1].Phase, t[n - 1].Omega};
+    }
+
+    size_t lo = 0, hi = n - 1;
+    while (hi - lo > 1) {
+        size_t mid = (lo + hi) / 2;
+        if (t[mid].FreqHz <= freqHz) lo = mid; else hi = mid;
+    }
+    const double f0 = t[lo].FreqHz, f1 = t[hi].FreqHz;
+    const double frac = (f1 > f0) ? (freqHz - f0) / (f1 - f0) : 0.0;
+    TWidebandResponse r;
+    r.Magnitude = t[lo].Magnitude + (t[hi].Magnitude - t[lo].Magnitude) * frac;
+    r.Omega = t[lo].Omega + (t[hi].Omega - t[lo].Omega) * frac;
+    r.Phase = LerpAngleWideband(t[lo].Phase, t[hi].Phase, frac);
+    return r;
+}
+
+// Analytically project one raw wideband tone into a single PQF subband, given
+// that subband's precomputed response r (from LookupWidebandResponse). The
+// even/odd phase-parity handling is empirical (see the long note at the
+// discovery call site): even subbands compose the phase directly, odd subbands
+// negate it. Factored out so discovery and the raw-domain (Option A) refit's
+// re-projection share exactly the same scale/parity formula.
+gha_info ProjectWidebandTone(int sb, const TWidebandResponse& r, const gha_info& wbTone)
+{
+    gha_info gha;
+    gha.frequency = (float)r.Omega;
+    gha.phase = (float)((sb % 2 == 0) ? (wbTone.phase + r.Phase) : (-wbTone.phase + r.Phase));
+    gha.magnitude = (float)(wbTone.magnitude * r.Magnitude);
+    return gha;
+}
+
+// Sum of squared error of a tone set against a PCM window -- the exact quantity
+// gha_adjust_info's Newton step minimizes, using libgha's own sine convention
+// (sin(frequency*n + phase), see gha_adjust_info_newton_md). Used to compare a
+// refined tone set against the analytic one and keep whichever actually has the
+// lower residual.
+double ToneSetSSE(const float* pcm, const vector<gha_info>& tones, size_t n)
+{
+    double sse = 0.0;
+    for (size_t i = 0; i < n; i++) {
+        double v = pcm[i];
+        for (const auto& t : tones) {
+            v -= (double)t.magnitude * std::sin((double)t.frequency * (double)i + (double)t.phase);
+        }
+        sse += v * v;
+    }
+    return sse;
+}
+
+// Ports TGhaProcessorBase::CheckResuidalAndApply's energy-ratio scan to the
+// 2048-sample wideband buffer. PQF decimation here is exactly 16x
+// (2048/SAMPLES_PER_SUBBAND(128)==16), so a 64-wideband-sample chunk is
+// exactly 4 subband-samples -- the SAME 32-point grid CheckResuidalAndApply
+// scans, just derived from wideband-domain data instead of subband-domain
+// data. Returns (start,end) in raw subband-sample-equivalent units (0-128,
+// multiples of 4), directly compatible with AdjustEnvelope -- or nullopt if
+// no reliably long contiguous "tone explains the energy here" run was found
+// (mirrors CheckResuidalAndApply's len<4 reject).
+//
+// Deliberately does not port the Repeat/shrink-refit loop or
+// LastResuidalEnergy diminishing-returns tracking: both are specific to
+// gha_adjust_info's multi-round refinement callback protocol, which
+// gha_extract_one's single-shot API has no equivalent of. A one-shot scan
+// is the correct simplification here, not a missing feature.
+std::optional<std::pair<uint32_t, uint32_t>> FindWidebandEnvelope(const float* before, const float* after)
+{
+    constexpr size_t kChunks = 32;
+    constexpr size_t kChunkSz = 2048 / kChunks; // 64 wideband samples == 4 subband-samples
+
+    uint32_t start = 0;
+    uint32_t curStart = 0;
+    uint32_t count = 0;
+    uint32_t len = 0;
+    bool found = false;
+
+    for (size_t c = 0; c < kChunks; c++) {
+        float energyIn = 0.0f, energyOut = 0.0f;
+        for (size_t j = 0; j < kChunkSz; j++) {
+            const size_t idx = c * kChunkSz + j;
+            energyIn += before[idx] * before[idx];
+            energyOut += after[idx] * after[idx];
+        }
+
+        if (energyIn / energyOut < 1) {
+            count = 0;
+            found = false;
+            curStart = (uint32_t)(c + 1) * 4;
+        } else {
+            count++;
+            if (count > len) {
+                len = count;
+                if (!found) {
+                    start = curStart;
+                    found = true;
+                }
+            }
+        }
+    }
+
+    if (len < 4) {
+        return std::nullopt;
+    }
+
+    const uint32_t end = start + len * 4;
+    return std::make_pair(start, end);
+}
+
+// Shared base for both GHA strategies. Owns the machinery common to the legacy
+// per-subband path and the wideband path: the 128-sample libgha context, the
+// result/history buffers, the ff_atrac3p synthesis unit, the static
+// psychoacoustic tables, and every helper used by both. The only thing that
+// differs between strategies is how each channel's tones are discovered and
+// refined into data.GhaInfos/data.Envelopes -- that is the AnalyzeChannels
+// hook; DoAnalize (the shared setup + result/filter tail) is a final template
+// method around it.
+class TGhaProcessorBase : public IGhaProcessor {
+protected:
     // Number of subbands to process;
     // No need to process all subbands.
     static constexpr size_t SUBBANDS = 8;
@@ -110,8 +262,7 @@ class TGhaProcessor : public IGhaProcessor {
         size_t FrameSz;
     };
 
-public:
-    TGhaProcessor(bool stereo)
+    explicit TGhaProcessorBase(bool stereo)
         : LibGhaCtx(gha_create_ctx(128))
         , Stereo(stereo)
     {
@@ -148,14 +299,23 @@ public:
         ChUnit.waves_info_prev->tones_present = false;
     }
 
-    ~TGhaProcessor()
+public:
+    ~TGhaProcessorBase() override
     {
         gha_free_ctx(LibGhaCtx);
     }
 
-    const TAt3PGhaData* DoAnalize(TBufPtr b1, TBufPtr b2, float *w1, float *w2) override;
+    const TAt3PGhaData* DoAnalize(TBufPtr b1, TBufPtr b2, float *w1, float *w2,
+        const float* raw1Cur, const float* raw2Cur) final;
+
+protected:
+    // The one stage that differs between strategies: discover and refine each
+    // channel's tones into data[ch].GhaInfos / data[ch].Envelopes, and return
+    // the total number of tones found across all channels. raws holds the raw
+    // (pre-PQF) per-channel signal, used only by the wideband strategy.
+    virtual size_t AnalyzeChannels(std::vector<TChannelData>& data,
+        const std::array<const float*, 2>& raws) = 0;
 
-private:
     void ApplyFilter(const TAt3PGhaData*, float *b1, float *b2);
     static void FillSubbandAth(float* out);
     static TAmpSfTab CreateAmpSfTab();
@@ -168,7 +328,6 @@ private:
     uint32_t AmplitudeToSf(float amp) const;
     bool CheckNextFrame(const float* nextSrc, const vector<gha_info>& ghaInfos) const;
 
-    bool DoRound(TChannelData& data, size_t& totalTones) const;
     bool PsyPreCheck(size_t sb, const struct gha_info& gha, const TChannelData& data) const;
     void FillResultBuf(const vector<TChannelData>& data);
 
@@ -186,12 +345,112 @@ private:
     Atrac3pChanUnitCtx ChUnit;
 };
 
-bool TGhaProcessor::StaticInited = false;
-float TGhaProcessor::SubbandAth[SUBBANDS];
-float TGhaProcessor::SineTab[2048];
-TGhaProcessor::TAmpSfTab TGhaProcessor::AmpSfTab;
+bool TGhaProcessorBase::StaticInited = false;
+float TGhaProcessorBase::SubbandAth[SUBBANDS];
+float TGhaProcessorBase::SineTab[2048];
+TGhaProcessorBase::TAmpSfTab TGhaProcessorBase::AmpSfTab;
+
+// Legacy per-subband ("narrowband") strategy: detect tones independently in
+// each PQF subband via repeated DoRound passes.
+class TSubbandGhaProcessor final : public TGhaProcessorBase {
+public:
+    explicit TSubbandGhaProcessor(bool stereo)
+        : TGhaProcessorBase(stereo)
+    {}
+
+protected:
+    size_t AnalyzeChannels(std::vector<TChannelData>& data,
+        const std::array<const float*, 2>& raws) override;
+
+private:
+    bool DoRound(TChannelData& data, size_t& totalTones) const;
+};
+
+// Wideband strategy: extract tones from the raw pre-PQF signal by matching
+// pursuit, project them into PQF subbands, then Newton-refine (subband-domain
+// by default, or raw-domain with WidebandRefineMode == 1).
+class TWidebandGhaProcessor final : public TGhaProcessorBase {
+public:
+    TWidebandGhaProcessor(bool stereo, int refineMode)
+        : TGhaProcessorBase(stereo)
+        , WidebandCtx(gha_create_ctx(2048))
+        , WidebandRefineMode(refineMode)
+    {
+        gha_set_max_magnitude(WidebandCtx, 1e9);
+        gha_set_upsample(WidebandCtx, 1);
+    }
+
+    ~TWidebandGhaProcessor() override
+    {
+        gha_free_ctx(WidebandCtx);
+    }
+
+protected:
+    size_t AnalyzeChannels(std::vector<TChannelData>& data,
+        const std::array<const float*, 2>& raws) override;
+
+private:
+    // Persistent state for ONE channel's wideband matching-pursuit
+    // extraction, carried across multiple WidebandExtractOne calls so that
+    // AnalyzeChannels can interleave extraction attempts between channels (see
+    // WidebandExtractOne) instead of letting one channel run to completion
+    // before the other gets a turn.
+    // One raw pre-projection wideband tone accepted during discovery, together
+    // with the exact (subband, freqIndex) GhaInfos entries its projection
+    // created. The projection map lets the raw-domain (Option A) refit update
+    // those specific entries in place after re-refining Info -- keeping the
+    // GhaInfos count, per-subband envelopes and the shared tone budget exactly
+    // as discovery left them (a clear-and-rebuild would desync all three).
+    struct TAcceptedWbTone {
+        gha_info Info;
+        std::vector<std::pair<uint8_t, uint32_t>> Proj;
+    };
+
+    struct TWidebandExtractState {
+        float WbScratch[2048];
+        // Untouched copy of the original 2048 raw signal (WbScratch is consumed
+        // by matching pursuit). The raw-domain refit needs the full original,
+        // the 2048-domain analog of DoRound refitting against the full subband
+        // PCM.
+        float WbOriginal[2048];
+        float MaxMagnitudeSeen = 0.0f;
+        int IterCount = 0;
+        // Per-subband envelope accumulated across the whole extraction
+        // (not written into data.Envelopes[] until CommitWidebandEnvelopes):
+        // two different wideband tones (different home subbands) can
+        // legitimately both project into the same neighbor subband via the
+        // home+-1 window, and whichever tone's insertion runs later must
+        // not silently clobber the other's envelope -- union instead.
+        bool SbHasEnvelope[SUBBANDS] = {false};
+        pair<uint32_t, uint32_t> SbEnvelopeUnion[SUBBANDS];
+
+        // Set per subband by RefineWidebandTones: true if the subband's tones
+        // were successfully Newton-refined against the real subband PCM (so
+        // its envelope was written by CheckResuidalAndApply as a side effect
+        // and CommitWidebandEnvelopes must NOT overwrite it with the analytic
+        // union), false if the refit was rejected and the analytic projection
+        // + union envelope was kept.
+        bool SbRefined[SUBBANDS] = {false};
+
+        // The raw pre-projection 2048-domain tones accepted this frame (in
+        // extraction order) with their projection maps. Consumed only by the
+        // raw-domain (Option A) refit; the subband-domain (Option B) refit
+        // ignores it.
+        vector<TAcceptedWbTone> AcceptedWbTones;
+    };
+
+    void InitWidebandExtractState(TWidebandExtractState& state, const float* rawPcm) const;
+    bool WidebandExtractOne(TChannelData& data, TWidebandExtractState& state, size_t& totalTones) const;
+    void RefineWidebandTones(TChannelData& data, TWidebandExtractState& state) const;
+    void RefineWidebandTonesSubbandDomain(TChannelData& data, TWidebandExtractState& state) const;
+    void RefineWidebandTonesRawDomain(TChannelData& data, TWidebandExtractState& state) const;
+    void CommitWidebandEnvelopes(TChannelData& data, const TWidebandExtractState& state) const;
 
-void TGhaProcessor::FillSubbandAth(float* out)
+    gha_ctx_t WidebandCtx;
+    const int WidebandRefineMode; // 0 = subband-domain refit, 1 = raw-domain refit
+};
+
+void TGhaProcessorBase::FillSubbandAth(float* out)
 {
     const auto ath = CalcATH(16 * 1024, 44100);
     #pragma GCC nounroll
@@ -205,7 +464,7 @@ void TGhaProcessor::FillSubbandAth(float* out)
     }
 }
 
-TGhaProcessor::TAmpSfTab TGhaProcessor::CreateAmpSfTab()
+TGhaProcessorBase::TAmpSfTab TGhaProcessorBase::CreateAmpSfTab()
 {
     TAmpSfTab AmpSfTab;
     for (int i = 0; i < (int)AmpSfTab.size(); i++) {
@@ -214,7 +473,7 @@ TGhaProcessor::TAmpSfTab TGhaProcessor::CreateAmpSfTab()
     return AmpSfTab;
 }
 
-void TGhaProcessor::GenWaves(const TAt3PGhaData::TWaveParam* param, size_t numWaves, size_t reg_offset, float* out, size_t outLimit)
+void TGhaProcessorBase::GenWaves(const TAt3PGhaData::TWaveParam* param, size_t numWaves, size_t reg_offset, float* out, size_t outLimit)
 {
     for (size_t w = 0; w < numWaves; w++, param++) {
         //std::cerr << "GenWaves : " << w << "  FreqIndex: " <<  param->FreqIndex << " phaseIndex: " << param->PhaseIndex << " ampSf " << param->AmpSf << std::endl;
@@ -230,11 +489,11 @@ void TGhaProcessor::GenWaves(const TAt3PGhaData::TWaveParam* param, size_t numWa
     }
 }
 
-void TGhaProcessor::CheckResuidalAndApply(float* resuidal, size_t size, void* d) noexcept
+void TGhaProcessorBase::CheckResuidalAndApply(float* resuidal, size_t size, void* d) noexcept
 {
     TChannelGhaCbCtx* ctx = (TChannelGhaCbCtx*)(d);
     const float* srcBuf = ctx->Data->SrcBuf + (ctx->Sb * SAMPLES_PER_SUBBAND);
-    //std::cerr << "TGhaProcessor::CheckResuidal " << srcBuf[0] << " " << srcBuf[1] << " " << srcBuf[2] << " " << srcBuf[3] <<  std::endl;
+    //std::cerr << "TGhaProcessorBase::CheckResuidal " << srcBuf[0] << " " << srcBuf[1] << " " << srcBuf[2] << " " << srcBuf[3] <<  std::endl;
 
     float resuidalEnergy = 0;
 
@@ -319,7 +578,7 @@ void TGhaProcessor::CheckResuidalAndApply(float* resuidal, size_t size, void* d)
     memcpy(b, resuidal, sizeof(float) * SAMPLES_PER_SUBBAND);
 }
 
-void TGhaProcessor::ApplyFilter(const TAt3PGhaData* d, float* b1, float* b2)
+void TGhaProcessorBase::ApplyFilter(const TAt3PGhaData* d, float* b1, float* b2)
 {
     for (size_t ch_num = 0; ch_num < 2; ch_num++)
         memset(ChUnit.channels[ch_num].tones_info, 0,
@@ -427,10 +686,13 @@ void TGhaProcessor::ApplyFilter(const TAt3PGhaData* d, float* b1, float* b2)
     std::swap(ChUnit.waves_info, ChUnit.waves_info_prev);
 }
 
-const TAt3PGhaData* TGhaProcessor::DoAnalize(TBufPtr b1, TBufPtr b2, float* w1, float* w2)
+// Shared template method: set up per-channel TChannelData, delegate tone
+// discovery/refinement to the strategy's AnalyzeChannels, then run the common
+// result-build + filter tail. The two strategies differ only in AnalyzeChannels.
+const TAt3PGhaData* TGhaProcessorBase::DoAnalize(TBufPtr b1, TBufPtr b2, float* w1, float* w2,
+    const float* raw1Cur, const float* raw2Cur)
 {
     vector<TChannelData> data((size_t)Stereo + 1);
-    bool progress[2] = {false};
 
     for (size_t ch = 0; ch < data.size(); ch++) {
         const float* bCur = (ch == 0) ? b1[0] : b2[0];
@@ -449,12 +711,7 @@ const TAt3PGhaData* TGhaProcessor::DoAnalize(TBufPtr b1, TBufPtr b2, float* w1,
         //}
     }
 
-    size_t totalTones = 0;
-    do {
-        for (size_t ch = 0; ch < data.size(); ch++) {
-            progress[ch] = DoRound(data[ch], totalTones);
-        }
-    } while ((progress[0] || progress[1]) && totalTones < 48);
+    const size_t totalTones = AnalyzeChannels(data, {raw1Cur, raw2Cur});
 
     if (totalTones == 0) {
         ApplyFilter(nullptr, w1, w2);
@@ -470,7 +727,57 @@ const TAt3PGhaData* TGhaProcessor::DoAnalize(TBufPtr b1, TBufPtr b2, float* w1,
     return  &ResultBuf;
 }
 
-bool TGhaProcessor::CheckNextFrame(const float* nextSrc, const vector<gha_info>& ghaInfos) const
+// Legacy per-subband strategy: repeated DoRound passes over all subbands until
+// no pass makes progress (or the shared 48-tone budget is hit). raws unused.
+size_t TSubbandGhaProcessor::AnalyzeChannels(std::vector<TChannelData>& data,
+    const std::array<const float*, 2>& /*raws*/)
+{
+    size_t totalTones = 0;
+    bool progress[2] = {false};
+    do {
+        for (size_t ch = 0; ch < data.size(); ch++) {
+            progress[ch] = DoRound(data[ch], totalTones);
+        }
+    } while ((progress[0] || progress[1]) && totalTones < 48);
+    return totalTones;
+}
+
+// Wideband strategy: round-robin matching-pursuit extraction between channels,
+// then per-channel refinement and envelope commit.
+size_t TWidebandGhaProcessor::AnalyzeChannels(std::vector<TChannelData>& data,
+    const std::array<const float*, 2>& raws)
+{
+    size_t totalTones = 0;
+    TWidebandExtractState wbState[2];
+    for (size_t ch = 0; ch < data.size(); ch++) {
+        InitWidebandExtractState(wbState[ch], raws[ch]);
+    }
+
+    // Round-robin between channels, one matching-pursuit extraction attempt at
+    // a time, same fairness contract as the legacy DoRound dispatch loop:
+    // without this, a dense channel 0 (e.g. a busy left channel) can run its
+    // own extraction all the way to the shared 48-tone budget before channel 1
+    // gets a single attempt.
+    bool wbProgress[2] = {data.size() > 0, data.size() > 1};
+    do {
+        for (size_t ch = 0; ch < data.size(); ch++) {
+            wbProgress[ch] = wbProgress[ch] && WidebandExtractOne(data[ch], wbState[ch], totalTones);
+        }
+    } while ((wbProgress[0] || (data.size() > 1 && wbProgress[1])) && totalTones < 48);
+
+    // Refinement stage: Newton-refine each subband's projected tones (Option B
+    // by default, Option A when WidebandRefineMode == 1).
+    for (size_t ch = 0; ch < data.size(); ch++) {
+        RefineWidebandTones(data[ch], wbState[ch]);
+    }
+
+    for (size_t ch = 0; ch < data.size(); ch++) {
+        CommitWidebandEnvelopes(data[ch], wbState[ch]);
+    }
+    return totalTones;
+}
+
+bool TGhaProcessorBase::CheckNextFrame(const float* nextSrc, const vector<gha_info>& ghaInfos) const
 {
     vector<TAt3PGhaData::TWaveParam> t;
     t.reserve(ghaInfos.size());
@@ -505,7 +812,7 @@ bool TGhaProcessor::CheckNextFrame(const float* nextSrc, const vector<gha_info>&
     return energyAfter < energyBefore;
 }
 
-bool TGhaProcessor::DoRound(TChannelData& data, size_t& totalTones) const
+bool TSubbandGhaProcessor::DoRound(TChannelData& data, size_t& totalTones) const
 {
     bool progress = false;
     for (size_t sb = 0; sb < SUBBANDS; sb++) {
@@ -645,7 +952,7 @@ bool TGhaProcessor::DoRound(TChannelData& data, size_t& totalTones) const
     return progress;
 }
 
-bool TGhaProcessor::PsyPreCheck(size_t sb, const struct gha_info& gha, const TChannelData& data) const
+bool TGhaProcessorBase::PsyPreCheck(size_t sb, const struct gha_info& gha, const TChannelData& data) const
 {
     if (isnan(gha.magnitude)) {
         return false;
@@ -665,7 +972,531 @@ bool TGhaProcessor::PsyPreCheck(size_t sb, const struct gha_info& gha, const TCh
     return false;
 }
 
-void TGhaProcessor::AdjustEnvelope(pair<uint32_t, uint32_t>& envelope, const pair<uint32_t, uint32_t>& src, uint32_t history)
+void TWidebandGhaProcessor::InitWidebandExtractState(TWidebandExtractState& state, const float* rawPcm) const
+{
+    memcpy(state.WbScratch, rawPcm, sizeof(state.WbScratch));
+    memcpy(state.WbOriginal, rawPcm, sizeof(state.WbOriginal));
+    state.MaxMagnitudeSeen = 0.0f;
+    state.IterCount = 0;
+    for (size_t sb = 0; sb < SUBBANDS; sb++) {
+        state.SbHasEnvelope[sb] = false;
+    }
+}
+
+// Performs ONE matching-pursuit extraction step for this channel: finds the
+// next-strongest wideband tone, projects it into its home subband +-1
+// window, and inserts it (all candidate subbands at once) if accepted.
+// Returns true if a tone was inserted and the caller should try again
+// (subject to its own round-robin budget), false once this channel's
+// extraction is genuinely finished for the frame (decayed below threshold,
+// below ATH everywhere, hit the global tone budget, or ran out of
+// iterations) -- mirrors DoRound's bool-progress contract so DoAnalize can
+// interleave extraction attempts between channels instead of letting one
+// channel's matching pursuit run to completion before the other gets a
+// turn (a dense channel 0 could otherwise consume the whole shared 48-tone
+// budget before channel 1 is ever tried).
+bool TWidebandGhaProcessor::WidebandExtractOne(TChannelData& data, TWidebandExtractState& state, size_t& totalTones) const
+{
+    // Global (both-channels) budget: ApplyFilter aborts if the combined
+    // tone count across channels exceeds 48 in one frame. totalTones is
+    // shared across both channels' state in DoAnalize, same contract as
+    // DoRound's totalTones parameter.
+    constexpr size_t kMaxTotalTones = 48;
+    constexpr size_t kMinFreqDistance = 20; // same guard DoRound uses
+    constexpr double kFreqMax = SUBBANDS * kWidebandSubbandBw; // 11025 Hz -- above this, no home subband exists
+    constexpr double kProjectGateRelative = 0.02; // -34dB relative to home subband's own response
+    // Hard cap on EXTRACTION ATTEMPTS for this channel across the whole
+    // frame, independent of accepted tones. gha_extract_one always removes
+    // real energy from WbScratch, so this isn't literally infinite, but for
+    // dense, non-sparse real audio (unlike a clean synthetic tone), matching
+    // pursuit can take an enormous number of vanishingly-small-decrement
+    // iterations to either fill the tone budget or decay below the 1/10
+    // threshold. A single call here may retry internally past several
+    // rejected candidates (see the "continue"s below) before returning,
+    // all counted against this same budget. Confirmed empirically: a real
+    // track hung (still running after 2+ minutes on a single 2048-sample
+    // frame) without this cap.
+    constexpr int kMaxExtractIterations = 200;
+
+    struct TCandidate {
+        size_t Sb;
+        uint32_t FreqIndex;
+        struct gha_info Gha;
+    };
+
+    float wbBefore[2048];
+    while (state.IterCount < kMaxExtractIterations) {
+        if (totalTones >= kMaxTotalTones) {
+            return false;
+        }
+        state.IterCount++;
+
+        memcpy(wbBefore, state.WbScratch, sizeof(state.WbScratch));
+        struct gha_info info;
+        gha_extract_one(state.WbScratch, &info, WidebandCtx);
+
+        if (isnan(info.magnitude) || info.magnitude <= 0) {
+            return false;
+        }
+
+        const double freqHz = info.frequency * kWidebandFs / (2.0 * M_PI);
+        if (freqHz >= kFreqMax) {
+            continue;
+        }
+
+        if (state.MaxMagnitudeSeen > 0 && info.magnitude < state.MaxMagnitudeSeen / 10) {
+            return false;
+        }
+
+        const int homeSb = std::clamp((int)std::floor(freqHz / kWidebandSubbandBw), 0, (int)SUBBANDS - 1);
+        const double homeMag = LookupWidebandResponse(homeSb, freqHz).Magnitude;
+
+        vector<TCandidate> candidates;
+        bool anyPassedAth = false;
+
+        for (int sb = std::max(0, homeSb - 1); sb <= std::min((int)SUBBANDS - 1, homeSb + 1); sb++) {
+            const TWidebandResponse r = LookupWidebandResponse(sb, freqHz);
+            if (r.Magnitude < kProjectGateRelative * std::max(homeMag, 1.0)) {
+                continue;
+            }
+
+            // Empirical scale/parity handling lives in ProjectWidebandTone:
+            // even subbands compose the wideband tone's phase directly, odd
+            // subbands NEGATE it (not a constant offset -- a first guess of
+            // +pi only matched at one frequency by coincidence). Consistent
+            // with alternating-band spectral inversion in a cosine-modulated
+            // filter bank; likely PQF's matrixing() writing
+            // samples[i*128]=res[15-i], i.e. each subband reading a DCT-IV
+            // coefficient at a parity-dependent index. The raw-domain refit
+            // re-projects through the SAME helper so its formula never drifts
+            // from discovery's.
+            const gha_info gha = ProjectWidebandTone(sb, r, info);
+
+            if (!PsyPreCheck(sb, gha, data)) {
+                continue;
+            }
+            anyPassedAth = true;
+
+            const auto freqIndex = GhaFreqToIndex(gha.frequency, sb);
+
+            const auto it = data.GhaInfos.lower_bound(freqIndex);
+            bool tooClose = false;
+            if (it != data.GhaInfos.end() && (it->first == freqIndex || it->first - freqIndex < kMinFreqDistance)) {
+                tooClose = true;
+            }
+            if (!tooClose && it != data.GhaInfos.begin()) {
+                auto prev = it;
+                prev--;
+                if (freqIndex - prev->first < kMinFreqDistance) {
+                    tooClose = true;
+                }
+            }
+            if (tooClose || data.SubbandDone[sb] >= 15) {
+                continue;
+            }
+
+            candidates.push_back({(size_t)sb, freqIndex, gha});
+        }
+
+        if (!anyPassedAth) {
+            // Signal below the hearing threshold everywhere this tone could
+            // land -- matching pursuit extracts in roughly decreasing
+            // magnitude order, so later tones are unlikely to fare better.
+            return false;
+        }
+
+        if (candidates.empty()) {
+            // This particular tone didn't yield any usable insertion
+            // (dedup/per-subband cap); its energy is already subtracted
+            // from WbScratch by gha_extract_one, so keep going.
+            continue;
+        }
+
+        if (totalTones + candidates.size() > kMaxTotalTones) {
+            return false;
+        }
+
+        // Where, within this frame, is the tone gha_extract_one just found
+        // actually present -- computed once per tone (a property of the
+        // tone's temporal presence in the signal, shared across every
+        // subband it projects into), not per candidate subband. On
+        // nullopt (couldn't reliably localize, mirroring
+        // CheckResuidalAndApply's len<4 reject), reject the tone for every
+        // subband: GhaInfos.insert must always be paired with a same-frame
+        // Envelopes[] write (see CommitWidebandEnvelopes's guardrail), so
+        // "insert anyway with a fallback envelope" is not a safe option
+        // here.
+        const auto env = FindWidebandEnvelope(wbBefore, state.WbScratch);
+        if (!env) {
+            continue;
+        }
+
+        TAcceptedWbTone accepted;
+        accepted.Info = info;
+        accepted.Proj.reserve(candidates.size());
+        for (const auto& c : candidates) {
+            data.GhaInfos.insert({c.FreqIndex, c.Gha});
+            data.MaxToneMagnitude[c.Sb] = std::max(data.MaxToneMagnitude[c.Sb], c.Gha.magnitude);
+            data.SubbandDone[c.Sb]++;
+            if (!state.SbHasEnvelope[c.Sb]) {
+                state.SbEnvelopeUnion[c.Sb] = *env;
+                state.SbHasEnvelope[c.Sb] = true;
+            } else {
+                state.SbEnvelopeUnion[c.Sb].first = std::min(state.SbEnvelopeUnion[c.Sb].first, env->first);
+                state.SbEnvelopeUnion[c.Sb].second = std::max(state.SbEnvelopeUnion[c.Sb].second, env->second);
+            }
+            accepted.Proj.emplace_back((uint8_t)c.Sb, c.FreqIndex);
+            totalTones++;
+        }
+
+        state.MaxMagnitudeSeen = std::max(state.MaxMagnitudeSeen, info.magnitude);
+        // Record the raw pre-projection tone plus the exact GhaInfos entries
+        // its projection created, so the raw-domain refit can re-refine Info
+        // and update those entries in place (see RefineWidebandTonesRawDomain).
+        // Recorded only on accept, so it stays in lockstep with GhaInfos.
+        state.AcceptedWbTones.push_back(std::move(accepted));
+        return true;
+    }
+    return false;
+}
+
+// Dispatches to the selected wideband refinement strategy (WidebandRefineMode,
+// set via the "ghawbrefine" advanced option). Both strategies take the same
+// discovery output (GhaInfos + envelope unions in state) and leave it in a
+// state CommitWidebandEnvelopes can finalize; they differ only in the domain
+// the Newton refit runs in.
+void TWidebandGhaProcessor::RefineWidebandTones(TChannelData& data, TWidebandExtractState& state) const
+{
+    if (WidebandRefineMode == 1) {
+        RefineWidebandTonesRawDomain(data, state);
+    } else {
+        RefineWidebandTonesSubbandDomain(data, state);
+    }
+}
+
+// Option B (default). Newton-refine each subband's projected tones against that
+// subband's own real 128-sample PCM, exactly as DoRound does for the legacy
+// path -- the analytic wideband projection is only a first guess, and
+// gha_adjust_info + CheckResuidalAndApply jointly minimize the actual
+// per-subband residual (the quantity ff_atrac3p subtracts and encodes). On any
+// sign of an ill-conditioned fit (boundary tones can produce near-singular
+// Hessians) the whole subband's refit is rejected and the analytic projection
+// is kept, so this can only improve or leave a subband unchanged, never worse.
+void TWidebandGhaProcessor::RefineWidebandTonesSubbandDomain(TChannelData& data, TWidebandExtractState& state) const
+{
+    // Drift guard bounds (see plan Step 3): reject a refit whose refined tone
+    // strays too far in frequency or magnitude from the analytic projection.
+    // The analytic projection is already a good, well-conditioned estimate
+    // (found in the 2048 domain), so a large jump signals a spurious local
+    // fit from a near-singular per-subband solve rather than a real
+    // improvement. Conservative to start; loosen only if verification shows
+    // legitimate refits being rejected.
+    constexpr uint32_t kMaxRefineDriftIdx = 40;
+    constexpr float kMaxRefineMagRatio = 4.0f;
+
+    for (size_t sb = 0; sb < SUBBANDS; sb++) {
+        auto cit = data.GhaInfos.lower_bound(sb << 10);
+        vector<gha_info> tmp;
+        for (auto it = cit; it != data.GhaInfos.end() && it->first < (sb + 1) << 10; it++) {
+            tmp.push_back(it->second);
+        }
+        if (tmp.empty()) {
+            continue;
+        }
+
+        // Untouched copy for the fallback path: gha_adjust_info mutates tmp in
+        // place, so the analytic values must be preserved separately.
+        const vector<gha_info> tmpAnalytic = tmp;
+
+        // Exactly DoRound's refit call: LibGhaCtx is the 128-sample context,
+        // and the pcm pointer is the raw subband buffer CheckResuidalAndApply
+        // also indexes internally (data.SrcBuf + sb*128). Never WidebandCtx
+        // here -- CheckResuidalAndApply aborts unless size == 128.
+        const float* srcB = data.SrcBuf + (sb * SAMPLES_PER_SUBBAND);
+        TChannelGhaCbCtx ctx(&data, sb);
+        do {
+            int ar = gha_adjust_info(srcB, tmp.data(), tmp.size(), LibGhaCtx, CheckResuidalAndApply, &ctx, ctx.FrameSz);
+            if (ar < 0) {
+                ctx.AdjustStatus = TChannelGhaCbCtx::EAdjustStatus::Error;
+            }
+        } while (ctx.AdjustStatus == TChannelGhaCbCtx::EAdjustStatus::Repeat);
+
+        bool accept = (ctx.AdjustStatus == TChannelGhaCbCtx::EAdjustStatus::Ok);
+
+        // Dup check (DoRound's dupFound): two refined tones can collapse onto
+        // the same quantized frequency index, which would corrupt the wave set.
+        if (accept) {
+            std::sort(tmp.begin(), tmp.end(), [](const gha_info& a, const gha_info& b) { return a.frequency < b.frequency; });
+            auto idx1 = GhaFreqToIndex(tmp[0].frequency, sb);
+            for (size_t i = 1; i < tmp.size() && accept; i++) {
+                auto idx2 = GhaFreqToIndex(tmp[i].frequency, sb);
+                if (idx2 == idx1) {
+                    accept = false;
+                } else {
+                    idx1 = idx2;
+                }
+            }
+        }
+
+        // Drift guard: pair each refined tone with the nearest analytic one by
+        // frequency index and require both frequency and magnitude to stay
+        // within bounds. tmpAnalytic is sorted the same way (matching pursuit
+        // inserts by index, so GhaInfos was already frequency-ordered within
+        // the subband; sort defensively to be safe).
+        if (accept) {
+            vector<gha_info> analyticSorted = tmpAnalytic;
+            std::sort(analyticSorted.begin(), analyticSorted.end(), [](const gha_info& a, const gha_info& b) { return a.frequency < b.frequency; });
+            for (size_t i = 0; i < tmp.size() && accept; i++) {
+                const uint32_t rIdx = GhaFreqToIndex(tmp[i].frequency, sb);
+                const uint32_t aIdx = GhaFreqToIndex(analyticSorted[i].frequency, sb);
+                const uint32_t d = (rIdx > aIdx) ? (rIdx - aIdx) : (aIdx - rIdx);
+                if (d > kMaxRefineDriftIdx) {
+                    accept = false;
+                    break;
+                }
+                const float am = analyticSorted[i].magnitude;
+                const float rm = tmp[i].magnitude;
+                if (isnan(rm) || rm <= 0.0f || am <= 0.0f ||
+                    rm > am * kMaxRefineMagRatio || am > rm * kMaxRefineMagRatio) {
+                    accept = false;
+                    break;
+                }
+            }
+        }
+
+        // Explicit "never worse" guard. libgha's Newton step has no line search,
+        // and CheckResuidalAndApply measures the residual against the raw PCM
+        // (not against the analytic projection), so a refit that clears the
+        // callback status and the drift guard can still have HIGHER SSE than the
+        // analytic tones. Compare the two tone sets directly against the real
+        // subband PCM and keep the refined set only if it genuinely lowers the
+        // residual. (Compared on the fitted float params; the emitted params are
+        // quantized, but the drift guard already bounds how far quantization can
+        // diverge, so this is a sound proxy for "the refit did not make it
+        // worse".)
+        if (accept) {
+            const double sseRefined = ToneSetSSE(srcB, tmp, SAMPLES_PER_SUBBAND);
+            const double sseAnalytic = ToneSetSSE(srcB, tmpAnalytic, SAMPLES_PER_SUBBAND);
+            if (!(sseRefined < sseAnalytic)) {
+                accept = false;
+            }
+        }
+
+        if (!accept) {
+            // Fallback: keep the analytic projection untouched. GhaInfos still
+            // holds the original tones; the analytic union envelope
+            // (state.SbEnvelopeUnion[sb]) is used by CommitWidebandEnvelopes.
+            // SbRefined[sb] stays false. totalTones is not touched (we did not
+            // add or remove a tone, only attempted to refine an existing set).
+            //
+            // CheckResuidalAndApply may have partially written data.Envelopes[sb]
+            // before returning Error; reset it to the INIT sentinel so the
+            // fallback union path in CommitWidebandEnvelopes owns it cleanly.
+            data.Envelopes[sb] = {TAt3PGhaData::INIT, TAt3PGhaData::INIT};
+            data.LastResuidalEnergy[sb] = 0.0f;
+            continue;
+        }
+
+        // Accept: replace the subband's GhaInfos entries with the refined tones
+        // at their new frequency indices (DoRound lines 740-749).
+        {
+            auto it = cit;
+            for (size_t i = 0; i < tmpAnalytic.size(); i++) {
+                it = data.GhaInfos.erase(it);
+            }
+            for (const auto& x : tmp) {
+                data.MaxToneMagnitude[sb] = std::max(data.MaxToneMagnitude[sb], x.magnitude);
+                const auto newIndex = GhaFreqToIndex(x.frequency, sb);
+                data.GhaInfos.insert({newIndex, x});
+            }
+        }
+
+        // CheckResuidalAndApply wrote data.Envelopes[sb] (start,end in raw
+        // units). Apply the same gapless collapse DoRound does: if the tone
+        // fills the frame and continues into the next, mark the stop point
+        // EMPTY_POINT (seamless continuation).
+        if (data.Envelopes[sb].second == SAMPLES_PER_SUBBAND) {
+            if (CheckNextFrame(data.SrcBufNext + SAMPLES_PER_SUBBAND * sb, tmp)) {
+                data.Envelopes[sb].second = TAt3PGhaData::EMPTY_POINT;
+            }
+        }
+        state.SbRefined[sb] = true;
+    }
+}
+
+// Option A (opt-in via ghawbrefine=1). Jointly Newton-refine the raw
+// pre-projection wideband tones against the full original 2048-sample signal
+// (WidebandCtx), then re-project the refined parameters into the subbands each
+// tone already occupies. This refines in the well-conditioned wideband domain
+// (no subband-boundary ill-conditioning at all), unlike the subband-domain
+// refit; the trade-off is that it minimizes the 2048-domain residual rather
+// than the exact per-subband residual that gets encoded, so it only helps to
+// the extent the calibration table is accurate. Left non-default because the
+// subband-domain refit already beats legacy on real audio; this is the
+// experimental alternative kept for A/B comparison.
+void TWidebandGhaProcessor::RefineWidebandTonesRawDomain(TChannelData& data, TWidebandExtractState& state) const
+{
+    auto& tones = state.AcceptedWbTones;
+    if (tones.empty()) {
+        return;
+    }
+
+    // Batch size bounds the joint Newton dimension. gha_adjust_info_newton_md
+    // allocas ~7 * dim * 2048 * 8 bytes (~115 KB per tone at sz=2048); a full
+    // 48-tone solve would be ~5.5 MB on the stack. 6 keeps it under ~700 KB
+    // while preserving the coupling that matters -- adjacent (frequency-sorted)
+    // tones interact, distant ones are ~orthogonal, so batching by frequency
+    // barely changes the fit.
+    constexpr size_t kRefineBatch = 6;
+    // Reject a refined tone that strayed too far from its analytic estimate --
+    // the sign of a divergent / ill-posed solve. ~60 Hz mirrors Option B's
+    // 40-freq-index bound (40/1024 * 1378 Hz subband bandwidth ~= 54 Hz).
+    constexpr double kMaxRefineDriftHz = 60.0;
+    constexpr float kMaxRefineMagRatio = 4.0f;
+
+    // Frequency-sort so batches group interacting neighbors; Proj travels with
+    // each tone. Snapshot the analytic (pre-refit) tones for the drift guard
+    // and for the collision fallback below.
+    std::sort(tones.begin(), tones.end(),
+        [](const TAcceptedWbTone& a, const TAcceptedWbTone& b) { return a.Info.frequency < b.Info.frequency; });
+    vector<gha_info> analytic(tones.size());
+    for (size_t i = 0; i < tones.size(); i++) {
+        analytic[i] = tones[i].Info;
+    }
+
+    // Batched joint refit against the full original signal. cb=nullptr: we only
+    // want refined params, no residual callback (gha.c guards `if (cb && ...)`);
+    // size_limit=0 uses the full 2048. A batch that fails to solve keeps its
+    // analytic values (tones[].Info unchanged for that batch).
+    for (size_t base = 0; base < tones.size(); base += kRefineBatch) {
+        const size_t k = std::min(kRefineBatch, tones.size() - base);
+        gha_info batch[kRefineBatch];
+        for (size_t j = 0; j < k; j++) {
+            batch[j] = tones[base + j].Info;
+        }
+        int rv = gha_adjust_info(state.WbOriginal, batch, k, WidebandCtx, nullptr, nullptr, 0);
+        if (rv < 0) {
+            continue;
+        }
+        for (size_t j = 0; j < k; j++) {
+            tones[base + j].Info = batch[j];
+        }
+    }
+
+    // Per-tone drift guard: fall back to the analytic tone if the refit
+    // diverged (NaN / non-positive magnitude, too-large frequency or magnitude
+    // move). The chosen source is what we re-project below.
+    vector<const gha_info*> src(tones.size());
+    for (size_t i = 0; i < tones.size(); i++) {
+        const gha_info& refined = tones[i].Info;
+        const gha_info& orig = analytic[i];
+        const double fRef = refined.frequency * kWidebandFs / (2.0 * M_PI);
+        const double fOrig = orig.frequency * kWidebandFs / (2.0 * M_PI);
+        bool ok = !isnan(refined.magnitude) && refined.magnitude > 0.0f &&
+                  std::abs(fRef - fOrig) <= kMaxRefineDriftHz &&
+                  refined.magnitude <= orig.magnitude * kMaxRefineMagRatio &&
+                  orig.magnitude <= refined.magnitude * kMaxRefineMagRatio;
+        src[i] = ok ? &refined : &orig;
+    }
+
+    // Upgrade the analytic projections that discovery already left in GhaInfos
+    // to the refined parameters, strictly IN PLACE. In wideband mode GhaInfos
+    // holds EXACTLY the projection entries recorded in the Proj maps (discovery
+    // is the only inserter) and every oldKey is globally unique, so we never
+    // clear/rebuild: for each drift-guard-passing tone we re-key each of its
+    // entries within its own subband and replace the value; a tone that failed
+    // the guard is simply left analytic. Crucially, on any within-subband key
+    // collision the tone is left analytic and NEVER dropped -- so every
+    // subband keeps exactly its discovery tone set, which keeps the per-subband
+    // envelope union and the tone count consistent (the earlier clear-and-
+    // rebuild could silently drop a projection on a double collision, leaving a
+    // subband's union describing a tone that no longer existed). The map KEY
+    // carries the emitted frequency index (FillResultBuf uses key & 1023); the
+    // value carries amp/phase. Envelopes stay from the discovery union
+    // (SbRefined left false), same as the analytic wideband path.
+    for (size_t i = 0; i < tones.size(); i++) {
+        if (src[i] != &tones[i].Info) {
+            continue; // drift guard rejected this tone -> keep its analytic entries
+        }
+        const gha_info& s = tones[i].Info; // refined
+        const double freqHz = s.frequency * kWidebandFs / (2.0 * M_PI);
+        for (const auto& pr : tones[i].Proj) {
+            const int sb = pr.first;
+            const uint32_t oldKey = pr.second;
+            const TWidebandResponse r = LookupWidebandResponse(sb, freqHz);
+            const gha_info gha = ProjectWidebandTone(sb, r, s);
+            const uint32_t newKey = GhaFreqToIndex(gha.frequency, sb);
+
+            auto oldIt = data.GhaInfos.find(oldKey);
+            if (oldIt == data.GhaInfos.end()) {
+                continue; // defensive: entry already moved (cannot happen given unique oldKeys)
+            }
+            if (newKey == oldKey) {
+                oldIt->second = gha; // same quantized index, just refine amp/phase
+            } else if (data.GhaInfos.find(newKey) == data.GhaInfos.end()) {
+                data.GhaInfos.erase(oldIt);
+                data.GhaInfos.insert({newKey, gha});
+            } else {
+                continue; // within-subband collision -> keep analytic, never drop
+            }
+            data.MaxToneMagnitude[sb] = std::max(data.MaxToneMagnitude[sb], gha.magnitude);
+        }
+    }
+}
+
+void TWidebandGhaProcessor::CommitWidebandEnvelopes(TChannelData& data, const TWidebandExtractState& state) const
+{
+    // Commit the accumulated per-subband envelope, deciding gapless
+    // continuation the same way DoRound does: reuse CheckNextFrame
+    // (unchanged) on this subband's own next-frame lookahead
+    // (data.SrcBufNext, already populated unconditionally at the top of
+    // DoAnalize) against ALL of this subband's current tones together (not
+    // per wideband-extraction-iteration -- a subband can hold contributions
+    // from multiple iterations, and checking continuation once per subband
+    // avoids redundant/conflicting decisions).
+    for (size_t sb = 0; sb < SUBBANDS; sb++) {
+        // Refined subbands already have their envelope written by
+        // CheckResuidalAndApply (measured against the real subband residual)
+        // and gapless-collapsed inside RefineWidebandTones -- do not overwrite
+        // it with the analytic union here.
+        if (state.SbRefined[sb]) {
+            continue;
+        }
+        if (!state.SbHasEnvelope[sb]) {
+            continue;
+        }
+        vector<gha_info> tmp;
+        auto cit = data.GhaInfos.lower_bound(sb << 10);
+        for (auto it = cit; it != data.GhaInfos.end() && it->first < (sb + 1) << 10; it++) {
+            tmp.push_back(it->second);
+        }
+        const bool cont = !tmp.empty() && CheckNextFrame(data.SrcBufNext + SAMPLES_PER_SUBBAND * sb, tmp);
+        const auto& u = state.SbEnvelopeUnion[sb];
+        data.Envelopes[sb] = {u.first, (u.second == SAMPLES_PER_SUBBAND && cont) ? TAt3PGhaData::EMPTY_POINT : u.second};
+    }
+
+    // FillResultBuf no longer requires a contiguous-from-0 run (it now sets
+    // NumToneBands to highestUsedSb+1 and leaves empty subbands in between
+    // as legitimate NumWaves==0 entries -- the wire format already supports
+    // that, see WriteTonalBlock's "if (numWaves == 0) continue;"). So unlike
+    // an earlier version of this code, there is no need to synthesize
+    // anchor tones purely to plug gaps below the highest used subband.
+
+    // Invariant every insert in WidebandExtractOne must preserve:
+    // GhaInfos.insert(sb) is always paired with a same-frame Envelopes[sb]
+    // write. Envelopes[] is array-initialized with a single aggregate
+    // initializer, so only Envelopes[0] starts at {INIT,INIT};
+    // Envelopes[1..7] value-initialize to {0,0}, and AdjustEnvelope aborts
+    // on an untouched {0,0} slot (its src.second==0 guard). A future edit
+    // that inserts without writing the envelope crashes the encoder here,
+    // not just misencodes -- this check exists to fail loudly and locally.
+    for (const auto& kv : data.GhaInfos) {
+        size_t sb = kv.first >> 10;
+        ASSERT(data.Envelopes[sb].first != 0 || data.Envelopes[sb].second != 0);
+    }
+}
+
+void TGhaProcessorBase::AdjustEnvelope(pair<uint32_t, uint32_t>& envelope, const pair<uint32_t, uint32_t>& src, uint32_t history)
 {
     if (src.first == 0 && history == TAt3PGhaData::EMPTY_POINT) {
         envelope.first = TAt3PGhaData::EMPTY_POINT;
@@ -688,30 +1519,28 @@ void TGhaProcessor::AdjustEnvelope(pair<uint32_t, uint32_t>& envelope, const pai
     }
 }
 
-void TGhaProcessor::FillResultBuf(const vector<TChannelData>& data)
+void TGhaProcessorBase::FillResultBuf(const vector<TChannelData>& data)
 {
-    uint32_t usedContiguousSb[2] = {0, 0};
-    uint32_t numTones[2] = {0, 0};
-
-    // TODO: This can be improved. Bitstream allows to set leader/folower flag for each band.
+    // NumToneBands is highestUsedSb+1, NOT a count of "contiguous" subbands:
+    // the wire format tolerates NumWaves==0 for any subband inside that
+    // range (WriteTonalBlock's "if (numWaves == 0) continue;" skips only the
+    // per-tone frequency/amplitude payload, the envelope/num-waves slots are
+    // still emitted), so a subband with no tones in the middle of the used
+    // range is legitimate and does not need to be filled with a synthetic
+    // tone. Confirmed empirically: without this, a 0-10kHz chirp whose swept
+    // tone's home subband reached 2+ lost the whole tone (silence from
+    // ~3.5kHz to 10kHz) because the old "stop at the first gap" walk
+    // truncated NumToneBands right after subband 0.
+    uint32_t numToneBandsUsed[2] = {0, 0};
     for (size_t ch = 0; ch < data.size(); ch++) {
-        int cur = -1;
+        int maxSb = -1;
         for (const auto& info : data[ch].GhaInfos) {
-            int sb = info.first >> 10;
-            if (sb == cur + 1) {
-                usedContiguousSb[ch]++;
-                numTones[ch]++;
-                cur = sb;
-            } else if (sb == cur) {
-                numTones[ch]++;
-                continue;
-            } else {
-                break;
-            }
+            maxSb = max(maxSb, (int)(info.first >> 10));
         }
+        numToneBandsUsed[ch] = (maxSb >= 0) ? (uint32_t)(maxSb + 1) : 0;
     }
 
-    bool leader = usedContiguousSb[1] > usedContiguousSb[0];
+    bool leader = numToneBandsUsed[1] > numToneBandsUsed[0];
 
     std::vector<TWavesChannel> history;
     history.reserve(data.size());
@@ -719,9 +1548,8 @@ void TGhaProcessor::FillResultBuf(const vector<TChannelData>& data)
     history.push_back(ResultBuf.Waves[0]);
 
     ResultBuf.SecondIsLeader = leader;
-    ResultBuf.NumToneBands = usedContiguousSb[leader];
+    ResultBuf.NumToneBands = numToneBandsUsed[leader];
 
-    TGhaInfoMap::const_iterator leaderStartIt;
     TGhaInfoMap::const_iterator folowerIt;
     if (data.size() == 2) {
         TWavesChannel& fWaves = ResultBuf.Waves[1];
@@ -731,71 +1559,58 @@ void TGhaProcessor::FillResultBuf(const vector<TChannelData>& data)
         fWaves.WaveParams.clear();
         fWaves.WaveSbInfos.clear();
         // Yes, see bitstream code
-        fWaves.WaveSbInfos.resize(usedContiguousSb[leader]);
+        fWaves.WaveSbInfos.resize(numToneBandsUsed[leader]);
         folowerIt = data[!leader].GhaInfos.begin();
-        leaderStartIt = data[leader].GhaInfos.begin();
     }
 
     const auto& ghaInfos = data[leader].GhaInfos;
     TWavesChannel& waves = ResultBuf.Waves[0];
     waves.WaveParams.clear();
     waves.WaveSbInfos.clear();
-    waves.WaveSbInfos.resize(usedContiguousSb[leader]);
-    auto it = ghaInfos.begin();
-    uint32_t prevSb = 0;
-    uint32_t index = 0;
+    waves.WaveSbInfos.resize(numToneBandsUsed[leader]);
 
-    if (usedContiguousSb[leader] == 0) {
+    if (numToneBandsUsed[leader] == 0) {
         return;
     }
 
-    while (it != ghaInfos.end()) {
-        const auto sb = ((it->first) >> 10);
-        if (sb >= usedContiguousSb[leader]) {
-            break;
-        }
-
-        const auto freqIndex = it->first & 1023;
-        const auto phaseIndex = GhaPhaseToIndex(it->second.phase);
-        const auto ampSf = AmplitudeToSf(it->second.magnitude);
+    // Walk subband indices explicitly (0..NumToneBands-1), not just the
+    // subbands that happen to have leader entries -- a gap subband still
+    // needs its WaveNums==0 default left alone and still needs to give the
+    // follower channel a chance to contribute independent tones there.
+    auto it = ghaInfos.begin();
+    for (uint32_t sb = 0; sb < numToneBandsUsed[leader]; sb++) {
+        const uint32_t index = (uint32_t)waves.WaveParams.size();
+        while (it != ghaInfos.end() && ((it->first) >> 10) == sb) {
+            const auto freqIndex = it->first & 1023;
+            const auto phaseIndex = GhaPhaseToIndex(it->second.phase);
+            const auto ampSf = AmplitudeToSf(it->second.magnitude);
 
-        waves.WaveSbInfos[sb].WaveNums++;
-        if (sb != prevSb) {
-            uint32_t histStop = TAt3PGhaData::INIT;
-            if (ResultBufHistory.Waves[0].WaveSbInfos.size() > prevSb) {
-                histStop = ResultBufHistory.Waves[0].WaveSbInfos[prevSb].Envelope.second;
-            }
-            AdjustEnvelope(waves.WaveSbInfos[prevSb].Envelope, data[leader].Envelopes[prevSb], histStop);
+            waves.WaveSbInfos[sb].WaveNums++;
+            waves.WaveParams.push_back(TAt3PGhaData::TWaveParam{freqIndex, ampSf, 1, phaseIndex});
+            it++;
+        }
 
-            // update index sb -> wave position index
+        if (waves.WaveSbInfos[sb].WaveNums > 0) {
             waves.WaveSbInfos[sb].WaveIndex = index;
 
-            // process folower if present
-            if (data.size() == 2) {
-                FillFolowerRes(data[leader].GhaInfos, &data[!leader], folowerIt, prevSb);
-                leaderStartIt = it;
+            uint32_t histStop = TAt3PGhaData::INIT;
+            if (ResultBufHistory.Waves[0].WaveSbInfos.size() > sb) {
+                histStop = ResultBufHistory.Waves[0].WaveSbInfos[sb].Envelope.second;
             }
-
-            prevSb = sb;
+            AdjustEnvelope(waves.WaveSbInfos[sb].Envelope, data[leader].Envelopes[sb], histStop);
         }
-        waves.WaveParams.push_back(TAt3PGhaData::TWaveParam{freqIndex, ampSf, 1, phaseIndex});
-        it++;
-        index++;
-    }
-
-    uint32_t histStop = (uint32_t)-2;
-    if (ResultBufHistory.Waves[0].WaveSbInfos.size() > prevSb) {
-        histStop = ResultBufHistory.Waves[0].WaveSbInfos[prevSb].Envelope.second;
-    }
+        // else: leave the resize()-provided default {EMPTY_POINT, EMPTY_POINT}
+        // -- data[leader].Envelopes[sb] was never written for an empty
+        // subband (see the insert/envelope-write invariant), so it must not
+        // be passed through AdjustEnvelope here.
 
-    TGhaProcessor::AdjustEnvelope(waves.WaveSbInfos[prevSb].Envelope, data[leader].Envelopes[prevSb], histStop);
-
-    if (data.size() == 2) {
-        FillFolowerRes(data[leader].GhaInfos, &data[!leader], folowerIt, prevSb);
+        if (data.size() == 2) {
+            FillFolowerRes(data[leader].GhaInfos, &data[!leader], folowerIt, sb);
+        }
     }
 }
 
-uint32_t TGhaProcessor::FillFolowerRes(const TGhaInfoMap& lGhaInfos, const TChannelData* src, TGhaInfoMap::const_iterator& it, const uint32_t curSb)
+uint32_t TGhaProcessorBase::FillFolowerRes(const TGhaInfoMap& lGhaInfos, const TChannelData* src, TGhaInfoMap::const_iterator& it, const uint32_t curSb)
 {
     uint32_t histStop = (uint32_t)-2;
     if (ResultBufHistory.Waves[1].WaveSbInfos.size() > curSb) {
@@ -848,7 +1663,7 @@ uint32_t TGhaProcessor::FillFolowerRes(const TGhaInfoMap& lGhaInfos, const TChan
     return nextSb;
 }
 
-uint32_t TGhaProcessor::AmplitudeToSf(float amp) const
+uint32_t TGhaProcessorBase::AmplitudeToSf(float amp) const
 {
     auto it = std::upper_bound(AmpSfTab.begin(), AmpSfTab.end(), amp);
     if (it != AmpSfTab.begin()) {
@@ -859,9 +1674,12 @@ uint32_t TGhaProcessor::AmplitudeToSf(float amp) const
 
 } // namespace
 
-std::unique_ptr<IGhaProcessor> MakeGhaProcessor0(bool stereo)
+std::unique_ptr<IGhaProcessor> MakeGhaProcessor0(bool stereo, bool wideband, int refineMode)
 {
-    return std::unique_ptr<TGhaProcessor>(new TGhaProcessor(stereo));
+    if (wideband) {
+        return std::unique_ptr<IGhaProcessor>(new TWidebandGhaProcessor(stereo, refineMode));
+    }
+    return std::unique_ptr<IGhaProcessor>(new TSubbandGhaProcessor(stereo));
 }
 
 } // namespace NAtracDEnc
diff --git a/src/atrac/at3p/at3p_gha.h b/src/atrac/at3p/at3p_gha.h
index 5b5c7de..456a69c 100644
--- a/src/atrac/at3p/at3p_gha.h
+++ b/src/atrac/at3p/at3p_gha.h
@@ -70,10 +70,17 @@ class IGhaProcessor {
 public:
     using TBufPtr = std::array<const float*, 2>;
     virtual ~IGhaProcessor() {}
-    virtual const TAt3PGhaData* DoAnalize(TBufPtr b1, TBufPtr b2, float* w1, float* w2) = 0;
+    // raw1Cur/raw2Cur: the same logical frame as b1[0]/b2[0] (Cur), but
+    // pre-PQF. Only used by the wideband detection path; the legacy
+    // per-subband path ignores them.
+    virtual const TAt3PGhaData* DoAnalize(TBufPtr b1, TBufPtr b2, float* w1, float* w2,
+        const float* raw1Cur, const float* raw2Cur) = 0;
 };
 
-std::unique_ptr<IGhaProcessor> MakeGhaProcessor0(bool stereo);
+// refineMode selects the wideband tone-refinement strategy (no effect unless
+// wideband is enabled): 0 = subband-domain Newton refit (default), 1 =
+// raw-2048-domain joint refit then re-project. See TAt3PEnc::TSettings.
+std::unique_ptr<IGhaProcessor> MakeGhaProcessor0(bool stereo, bool wideband, int refineMode = 0);
 
 } // namespace NAtracDEnc
 
diff --git a/src/atrac/at3p/at3p_gha_ut.cpp b/src/atrac/at3p/at3p_gha_ut.cpp
index a3cacec..597fcd7 100644
--- a/src/atrac/at3p/at3p_gha_ut.cpp
+++ b/src/atrac/at3p/at3p_gha_ut.cpp
@@ -2,6 +2,7 @@
 #include "at3p_gha.h"
 #include "oma.h"
 #include "util.h"
+#include <atrac/atrac3plus_pqf/atrac3plus_pqf.h>
 #include <gtest/gtest.h>
 #include <cmath>
 #include <vector>
@@ -33,7 +34,7 @@ static void atde_noinline Gen(const TTestParam& p, vector<float>& out)
 static TAt3PGhaData DoAnalize(IGhaProcessor* p, IGhaProcessor::TBufPtr b1, IGhaProcessor::TBufPtr b2) {
     float w1[2048] = {0};
     float w2[2048] = {0};
-    return *p->DoAnalize(b1, b2, w1, w2);
+    return *p->DoAnalize(b1, b2, w1, w2, nullptr, nullptr);
 }
 
 static const TAt3PGhaData atde_noinline GenAndRunGha(vector<TTestParam> p1, vector<TTestParam> p2)
@@ -54,7 +55,7 @@ static const TAt3PGhaData atde_noinline GenAndRunGha(vector<TTestParam> p1, vect
         }
     }
 
-    auto processor = MakeGhaProcessor0(!p2.empty());
+    auto processor = MakeGhaProcessor0(!p2.empty(), false);
     const float* b1 = buf1.data();
     const float* b2 = buf2.empty() ? nullptr : buf2.data();
 
@@ -175,13 +176,26 @@ TEST(AT3PGHA, 689hz0625_2067hz1875__full_frame_mono) {
 }
 
 TEST(AT3PGHA, 689hz0625_4823hz4375__full_frame_mono) {
+    // The abrupt on/off edges of the second 689.0625Hz segment (a "click" at
+    // samples 128 and 256) splatter real, ATH-passing energy into subband 2
+    // as well as subband 0 -- DoRound's own CheckResuidalAndApply validation
+    // (round 2+) confirms it explains the residual across the WHOLE
+    // subband-2 window (envelope (0,31), i.e. start=0/end=~128), not a
+    // marginal len>=4 borderline pass, so this is a real detected tone, not
+    // noise. FillResultBuf now legitimately reports it (NumToneBands=3,
+    // subband 1 empty in between) instead of the old contiguous-run walk
+    // silently truncating everything past subband 0's first gap.
     auto res = GenAndRunGha({{689.0625f, 0, 32768, 0, 128}, {689.0625f, 0, 16384, 256, 384}}, {});
-    EXPECT_EQ(res.NumToneBands, 1);
-    EXPECT_EQ(res.Waves[0].WaveParams.size(), 1);
-    EXPECT_EQ(res.Waves[0].WaveSbInfos.size(), 1);
+    EXPECT_EQ(res.NumToneBands, 3);
+    EXPECT_EQ(res.Waves[0].WaveParams.size(), 2);
+    EXPECT_EQ(res.Waves[0].WaveSbInfos.size(), 3);
     EXPECT_EQ(res.GetNumWaves(0, 0), 1);
     EXPECT_EQ(res.GetWaves(0, 0).second, 1);
     EXPECT_EQ(res.GetWaves(0, 0).first->FreqIndex, 512);
+    EXPECT_EQ(res.GetNumWaves(0, 1), 0);
+    EXPECT_EQ(res.GetNumWaves(0, 2), 1);
+    EXPECT_EQ(res.GetWaves(0, 2).second, 1);
+    EXPECT_EQ(res.GetWaves(0, 2).first->FreqIndex, 512);
     Dumper.Dump(&res, 1, 1);
 }
 
@@ -475,7 +489,7 @@ TEST(AT3PGHA, 100hz__two_frames_mono) {
     memset(&buf[128], 0, sizeof(float) * 128);
 
     std::vector<TAt3PGhaData> resBuf;
-    auto processor = MakeGhaProcessor0(false);
+    auto processor = MakeGhaProcessor0(false, false);
 
     {
         const auto res = DoAnalize(processor.get(), {&buf[0], &buf[2048]}, {nullptr, nullptr});
@@ -520,7 +534,7 @@ TEST(AT3PGHA, 100hz_than_500hz_than_100hz__3_frames_mono) {
     memset(&buf[128], 0, sizeof(float) * 128);
 
     std::vector<TAt3PGhaData> resBuf;
-    auto processor = MakeGhaProcessor0(false);
+    auto processor = MakeGhaProcessor0(false, false);
 
     {
         const auto res = DoAnalize(processor.get(), {&buf[0], &buf[2048]}, {nullptr, nullptr});
@@ -580,7 +594,7 @@ TEST(AT3PGHA, 100hz__phase_two_frames_mono) {
     memcpy(&buf[2048], &buf[128], sizeof(float) * 128);
     memset(&buf[128], 0, sizeof(float) * 128);
 
-    auto processor = MakeGhaProcessor0(false);
+    auto processor = MakeGhaProcessor0(false, false);
     const auto res = DoAnalize(processor.get(), {&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
@@ -601,7 +615,7 @@ TEST(AT3PGHA, 689hz0625__two_frames_mono) {
     memcpy(&buf[2048], &buf[128], sizeof(float) * 128);
     memset(&buf[128], 0, sizeof(float) * 128);
 
-    auto processor = MakeGhaProcessor0(false);
+    auto processor = MakeGhaProcessor0(false, false);
     const auto res = DoAnalize(processor.get(), {&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
@@ -622,7 +636,7 @@ TEST(AT3PGHA, 689hz0625_1000hz__two_frames_mono) {
     memcpy(&buf[2048], &buf[128], sizeof(float) * 128);
     memset(&buf[128], 0, sizeof(float) * 128);
 
-    auto processor = MakeGhaProcessor0(false);
+    auto processor = MakeGhaProcessor0(false, false);
     const auto res = DoAnalize(processor.get(), {&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
@@ -645,7 +659,7 @@ TEST(AT3PGHA, 500hz_1000hz__two_frames_mono) {
     memcpy(&buf[2048], &buf[128], sizeof(float) * 128);
     memset(&buf[128], 0, sizeof(float) * 128);
 
-    auto processor = MakeGhaProcessor0(false);
+    auto processor = MakeGhaProcessor0(false, false);
     const auto res = DoAnalize(processor.get(), {&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
@@ -668,7 +682,7 @@ TEST(AT3PGHA, 500hz_1000hz__phase_two_frames_mono) {
     memcpy(&buf[2048], &buf[128], sizeof(float) * 128);
     memset(&buf[128], 0, sizeof(float) * 128);
 
-    auto processor = MakeGhaProcessor0(false);
+    auto processor = MakeGhaProcessor0(false, false);
     const auto res = DoAnalize(processor.get(), {&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
@@ -693,7 +707,7 @@ TEST(AT3PGHA, 250hz_500hz_1000hz__two_frames_mono) {
     memcpy(&buf[2048], &buf[128], sizeof(float) * 128);
     memset(&buf[128], 0, sizeof(float) * 128);
 
-    auto processor = MakeGhaProcessor0(false);
+    auto processor = MakeGhaProcessor0(false, false);
     const auto res = DoAnalize(processor.get(), {&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
@@ -720,7 +734,7 @@ TEST(AT3PGHA, 250hz_500hz_1000hz_1200hz__two_frames_mono) {
     memcpy(&buf[2048], &buf[128], sizeof(float) * 128);
     memset(&buf[128], 0, sizeof(float) * 128);
 
-    auto processor = MakeGhaProcessor0(false);
+    auto processor = MakeGhaProcessor0(false, false);
     const auto res = DoAnalize(processor.get(), {&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
@@ -746,18 +760,18 @@ void CheckReduction(float f, uint32_t expFreqIndex){
     memcpy(&buf[4096], &buf[256], sizeof(float) * 128);
     memset(&buf[128], 0, sizeof(float) * 256);
 
-    auto processor = MakeGhaProcessor0(false);
+    auto processor = MakeGhaProcessor0(false, false);
     float w1[2048] = {0};
     float w2[2048] = {0};
     {
-        const auto res = processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr}, w1, w2);
+        const auto res = processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr}, w1, w2, nullptr, nullptr);
         EXPECT_EQ(res->NumToneBands, 1);
         EXPECT_EQ(res->Waves[0].WaveParams.size(), 1);
         EXPECT_EQ(res->GetWaves(0, 0).first[0].FreqIndex, expFreqIndex);
     }
     {
         memcpy(&w1[0], &buf[0], sizeof(float) * 2048);
-        const auto res = processor->DoAnalize({&buf[2048], &buf[4096]}, {nullptr, nullptr}, w1, w2);
+        const auto res = processor->DoAnalize({&buf[2048], &buf[4096]}, {nullptr, nullptr}, w1, w2, nullptr, nullptr);
         EXPECT_EQ(res->NumToneBands, 1);
         EXPECT_EQ(res->Waves[0].WaveParams.size(), 1);
         EXPECT_EQ(res->GetWaves(0, 0).first[0].FreqIndex, expFreqIndex);
@@ -785,3 +799,474 @@ TEST(AT3PGHA, 999hz948_long_frame_mono) {
 TEST(AT3PGHA, 1345hz826_long_frame_mono) {
     CheckReduction(1345.826, 1000);
 }
+
+// ---- Wideband GHA path (GHA_WIDEBAND) ----
+//
+// Unlike the tests above, which fabricate subband-domain buffers directly
+// (bypassing the real PQF filter), the wideband path's correctness depends
+// on the ACTUAL PQF analysis output being consistent with the raw PCM it
+// was derived from (its magnitude/phase composition was calibrated against
+// the real at3plus_pqf_do_analyse -- see at3p_pqf_wideband_table.h and the
+// "wideband GHA + PQF-domain projection" plan). These tests run the real
+// PQF filter to build a consistent (raw, PQF) pair, matching how
+// TAt3PEnc::TImpl::EncodeFrame does it in production.
+
+static void atde_noinline GenWideband(float freqHz, float amplitude, float* out, size_t len)
+{
+    const double omega = 2.0 * M_PI * freqHz / 44100.0;
+    for (size_t i = 0; i < len; i++) {
+        out[i] += (float)(amplitude * sin(omega * i));
+    }
+}
+
+// Range variant, mirroring the legacy Gen/TTestParam::start,end pattern
+// already in this file: only fills [startSample, endSample), leaving the
+// rest of the buffer untouched (silent, if not otherwise written).
+static void atde_noinline GenWidebandRange(float freqHz, float amplitude, float* out,
+    size_t startSample, size_t endSample)
+{
+    const double omega = 2.0 * M_PI * freqHz / 44100.0;
+    for (size_t i = startSample; i < endSample; i++) {
+        out[i] += (float)(amplitude * sin(omega * i));
+    }
+}
+
+// Two consecutive frames of raw PCM through the real PQF filter, matching
+// EncodeFrame's Cur/Next buffer convention (frame 0 = Cur, frame 1 = Next).
+struct TWidebandPqfFixture {
+    float Raw0[2048] = {0};
+    float Raw1[2048] = {0};
+    float Pqf0[2048];
+    float Pqf1[2048];
+
+    void Run() {
+        at3plus_pqf_a_ctx_t ctx = at3plus_pqf_create_a_ctx();
+        at3plus_pqf_do_analyse(ctx, Raw0, Pqf0);
+        at3plus_pqf_do_analyse(ctx, Raw1, Pqf1);
+        at3plus_pqf_free_a_ctx(ctx);
+    }
+};
+
+TEST(AT3PGHAWideband, SingleToneRoundTrips) {
+    TWidebandPqfFixture fx;
+    // 2000Hz sits in the middle of subband 1 (1378-2756Hz) -- away from any
+    // subband boundary, so this is a plain "does the projected amplitude
+    // land in the right ballpark" check, guarding the empirical
+    // tone.Magnitude * response.Magnitude scale equivalence against silent
+    // drift (see FillChannelDataWideband's comment on this).
+    GenWideband(2000.0f, 16384.0f, fx.Raw0, 2048);
+    GenWideband(2000.0f, 16384.0f, fx.Raw1, 2048);
+    fx.Run();
+
+    auto processor = MakeGhaProcessor0(false, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const float* raw1Cur = fx.Raw0;
+    const auto* res = processor->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, raw1Cur, nullptr);
+
+    ASSERT_NE(res, nullptr);
+    ASSERT_GE(res->NumToneBands, 2u); // subband 0 (anchor) + subband 1 (the tone)
+    ASSERT_GT(res->GetNumWaves(0, 1), 0u);
+    // AmpSf 63 is the top of the table (see CreateAmpSfTab / AmplitudeToSf);
+    // a 16384-amplitude tone should land solidly in the upper range, not
+    // near the bottom -- a coarse bound, not a precise one, but enough to
+    // catch a scale-formula regression (e.g. an accidental extra factor of
+    // response.Magnitude, or dropping the tone.Magnitude term entirely).
+    EXPECT_GE(res->GetWaves(0, 1).first[0].AmpSf, 40u);
+}
+
+TEST(AT3PGHAWideband, StereoManyTonesStaysUnderBudget) {
+    // Enough simultaneous tones, across both channels, that a budget-check
+    // bug (see FillChannelDataWideband's "shared totalTones across both
+    // channels" requirement) would either abort() in ApplyFilter (>48
+    // combined) or, if under-counted, silently misbehave. This is
+    // primarily a "does this complete without crashing" regression guard.
+    TWidebandPqfFixture fx1, fx2;
+    for (int k = 0; k < 12; k++) {
+        float f = 300.0f + k * 210.0f; // spread across subbands 0-4ish
+        GenWideband(f, 3000.0f, fx1.Raw0, 2048);
+        GenWideband(f, 3000.0f, fx1.Raw1, 2048);
+        GenWideband(f + 55.0f, 3000.0f, fx2.Raw0, 2048);
+        GenWideband(f + 55.0f, 3000.0f, fx2.Raw1, 2048);
+    }
+    fx1.Run();
+    fx2.Run();
+
+    auto processor = MakeGhaProcessor0(true, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = processor->DoAnalize({fx1.Pqf0, fx1.Pqf1}, {fx2.Pqf0, fx2.Pqf1}, w1, w2, fx1.Raw0, fx2.Raw0);
+
+    ASSERT_NE(res, nullptr);
+    size_t totalWaves = 0;
+    for (size_t sb = 0; sb < res->NumToneBands; sb++) {
+        totalWaves += res->GetNumWaves(0, sb);
+        if (!res->ToneSharing[sb]) {
+            totalWaves += res->GetNumWaves(1, sb);
+        }
+    }
+    EXPECT_LE(totalWaves, 48u);
+}
+
+// ---- Envelope (onset/offset) detection ----
+//
+// FindWidebandEnvelope's wire-grid units: raw subband-sample-equivalent
+// position (0-128) divided by 4 gives the 32-point wire grid AdjustEnvelope
+// produces. A raw sample index i (0-2047, wideband domain) corresponds to
+// wire-grid point i/16/4 = i/64.
+
+TEST(AT3PGHAWideband, OnsetMidFrameDetected) {
+    TWidebandPqfFixture fx;
+    // Silent for the first half of Raw0, on for the second half and all of
+    // Raw1 -- isolates onset detection from the gapless-continuation path.
+    GenWidebandRange(2000.0f, 16384.0f, fx.Raw0, 1024, 2048);
+    GenWideband(2000.0f, 16384.0f, fx.Raw1, 2048);
+    fx.Run();
+
+    auto processor = MakeGhaProcessor0(false, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = processor->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    ASSERT_NE(res, nullptr);
+    ASSERT_GT(res->GetNumWaves(0, 1), 0u);
+    auto env = res->GetEnvelope(0, 1);
+    // Onset at raw sample 1024 == wire-grid point 16. Coarse bound (not
+    // exact), same spirit as SingleToneRoundTrips's AmpSf check -- the
+    // single-shot fit over a half-silent buffer has some estimation slop,
+    // this just needs to prove mid-frame onset is detected at all, not "at
+    // frame start" (0) or "not detected" (EMPTY_POINT).
+    EXPECT_NE(env.first, TAt3PGhaData::EMPTY_POINT);
+    EXPECT_GE(env.first, 8u);
+    EXPECT_LE(env.first, 24u);
+}
+
+TEST(AT3PGHAWideband, OffsetMidFrameDetected) {
+    TWidebandPqfFixture fx;
+    // On for the first half of Raw0, silent after -- Raw1 stays silent too
+    // so there's no continuation to worry about.
+    GenWidebandRange(2000.0f, 16384.0f, fx.Raw0, 0, 1024);
+    fx.Run();
+
+    auto processor = MakeGhaProcessor0(false, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = processor->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    ASSERT_NE(res, nullptr);
+    ASSERT_GT(res->GetNumWaves(0, 1), 0u);
+    auto env = res->GetEnvelope(0, 1);
+    // Offset at raw sample 1024 == wire-grid point 16. Must not be 31 (ran
+    // to frame end) or EMPTY_POINT (declared gapless).
+    EXPECT_NE(env.second, TAt3PGhaData::EMPTY_POINT);
+    EXPECT_GE(env.second, 8u);
+    EXPECT_LE(env.second, 24u);
+}
+
+TEST(AT3PGHAWideband, GaplessAcrossFrames) {
+    TWidebandPqfFixture fx;
+    // Unbroken tone spanning both frames -- regression guard that
+    // CheckNextFrame-based continuation still collapses .second to
+    // EMPTY_POINT now that envelopes are computed, not hardcoded.
+    GenWideband(2000.0f, 16384.0f, fx.Raw0, 2048);
+    GenWideband(2000.0f, 16384.0f, fx.Raw1, 2048);
+    fx.Run();
+
+    auto processor = MakeGhaProcessor0(false, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = processor->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    ASSERT_NE(res, nullptr);
+    ASSERT_GT(res->GetNumWaves(0, 1), 0u);
+    auto env = res->GetEnvelope(0, 1);
+    EXPECT_EQ(env.second, TAt3PGhaData::EMPTY_POINT);
+}
+
+TEST(AT3PGHAWideband, OverlappingTonesShareSubbandEnvelopeUnion) {
+    // Two tones, home subbands 0 and 2, both close enough to subband 1's
+    // edges to project into it as a shared neighbor -- with DIFFERENT
+    // on/off timing. Guards the union-not-overwrite merge policy in
+    // FillChannelDataWideband: subband 1 must reflect tone A's full-frame
+    // coverage, not get truncated to tone B's later-starting window by a
+    // naive overwrite. (Deliberately keeps tone A's home subband at 0, not
+    // 1/3 as in an earlier draft of this test: with both tones far from
+    // subband 0, its own real content is leakage-only and can be so small
+    // that a single-shot Newton fit on near-silence produces a wildly
+    // spurious huge-magnitude "tone" there, which the anchor pass's energy-
+    // ratio validation correctly rejects -- collapsing NumToneBands to 0 via
+    // the contiguous-from-subband-0 bitstream constraint, unrelated to what
+    // this test is actually checking. Anchoring tone A directly in subband 0
+    // sidesteps that pre-existing edge case entirely.)
+    TWidebandPqfFixture fx;
+    GenWideband(1300.0f, 12000.0f, fx.Raw0, 2048);           // home sb=0, full frame, near the 1378Hz edge
+    GenWidebandRange(2800.0f, 12000.0f, fx.Raw0, 1024, 2048); // home sb=2, second half only, near the 2756Hz edge
+    GenWideband(1300.0f, 12000.0f, fx.Raw1, 2048);
+    GenWidebandRange(2800.0f, 12000.0f, fx.Raw1, 1024, 2048);
+    fx.Run();
+
+    auto processor = MakeGhaProcessor0(false, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = processor->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    ASSERT_NE(res, nullptr);
+    ASSERT_GE(res->NumToneBands, 2u);
+    ASSERT_GT(res->GetNumWaves(0, 1), 0u) << "expected both tones to project into shared subband 1";
+    auto env = res->GetEnvelope(0, 1);
+    // Tone A alone covers the whole frame -- the union must reflect that,
+    // not tone B's later start (~wire-grid 16).
+    EXPECT_TRUE(env.first == TAt3PGhaData::EMPTY_POINT || env.first < 8u);
+}
+
+// --- Newton refinement (RefineWidebandTones) ---------------------------------
+
+TEST(AT3PGHAWideband, RefinementKeepsToneCountMidSubbandTone) {
+    // A clean mid-subband tone (2000Hz, middle of subband 1). The refinement
+    // pass must not change how many tones/bands come out -- it only refines
+    // the parameters of the already-discovered set (or falls back), never
+    // adds or drops a tone. Guards the "totalTones is not touched" contract.
+    TWidebandPqfFixture fx;
+    GenWideband(2000.0f, 16384.0f, fx.Raw0, 2048);
+    GenWideband(2000.0f, 16384.0f, fx.Raw1, 2048);
+    fx.Run();
+
+    auto processor = MakeGhaProcessor0(false, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = processor->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    ASSERT_NE(res, nullptr);
+    // Same expectation as SingleToneRoundTrips: subband 0 (anchor leakage) +
+    // subband 1 (the tone). The refit must leave that structure intact.
+    ASSERT_GE(res->NumToneBands, 2u);
+    ASSERT_EQ(res->GetNumWaves(0, 1), 1u) << "refinement must not split or drop the single tone";
+    // A 16384-amplitude tone must still land solidly in the upper AmpSf range
+    // after refit -- catches a refit that corrupts magnitude but still passes
+    // the drift guard's ratio bound coincidentally.
+    EXPECT_GE(res->GetWaves(0, 1).first[0].AmpSf, 40u);
+}
+
+TEST(AT3PGHAWideband, RefinementSeparatesTwoToneSubband) {
+    // Two well-separated tones that both land in subband 1 (1378-2756Hz):
+    // 1700Hz and 2400Hz. This is the only wideband test that exercises the
+    // JOINT multi-tone (k=2) Newton refit -- gha_adjust_info refining both
+    // tones of the subband simultaneously against the real subband PCM. A
+    // refit that diverged, collapsed the two onto one frequency (dupFound),
+    // or otherwise corrupted the set would either fall back to the analytic
+    // pair or drop one; either way the property to hold is that subband 1
+    // still carries two distinct tones with distinct quantized frequency
+    // indices. (The end-to-end residual-dB improvement from refit is measured
+    // separately and robustly by the encoder chirp A/B, which does not depend
+    // on ApplyFilter's cross-frame tone-synthesis scale conventions.)
+    TWidebandPqfFixture fx;
+    GenWideband(1700.0f, 12000.0f, fx.Raw0, 2048);
+    GenWideband(2400.0f, 9000.0f, fx.Raw0, 2048);
+    GenWideband(1700.0f, 12000.0f, fx.Raw1, 2048);
+    GenWideband(2400.0f, 9000.0f, fx.Raw1, 2048);
+    fx.Run();
+
+    auto processor = MakeGhaProcessor0(false, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = processor->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    ASSERT_NE(res, nullptr);
+    ASSERT_GE(res->NumToneBands, 2u);
+    ASSERT_EQ(res->GetNumWaves(0, 1), 2u) << "both tones must survive the joint refit in subband 1";
+    auto w = res->GetWaves(0, 1);
+    EXPECT_NE(w.first[0].FreqIndex, w.first[1].FreqIndex) << "the two tones must keep distinct frequency indices";
+}
+
+TEST(AT3PGHAWideband, RefinementFallbackOnBoundaryToneNoBlowup) {
+    // A tone sitting essentially ON the subband 1/2 boundary (2756Hz). This
+    // is exactly the ill-conditioned regime the drift guard exists for: a
+    // per-subband Newton solve on a boundary tone can produce a near-singular
+    // Hessian and a spurious huge-magnitude fit. Whether the refit is accepted
+    // (within guard) or rejected (fallback to analytic), the result must be a
+    // sane tone -- never a NaN/garbage magnitude, never an abort(). Reaching
+    // this assertion at all proves no abort() fired in
+    // CheckResuidalAndApply/AdjustEnvelope.
+    TWidebandPqfFixture fx;
+    GenWideband(2756.0f, 14000.0f, fx.Raw0, 2048);
+    GenWideband(2756.0f, 14000.0f, fx.Raw1, 2048);
+    fx.Run();
+
+    auto processor = MakeGhaProcessor0(false, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = processor->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    ASSERT_NE(res, nullptr);
+    // The tone should land in subband 1 or 2 (its home±1 window). Whichever
+    // subbands hold tones, every emitted wave must have a sane amplitude
+    // index (the AmpSf table is 0..63; a blown-up magnitude would still clamp
+    // to 63 via AmplitudeToSf, so also assert it's not implausibly maxed for
+    // a 14000-amplitude tone that projects attenuated across the boundary --
+    // i.e. it must be a real fit, not a saturated garbage one).
+    bool anyTone = false;
+    for (int sb = 0; sb < res->NumToneBands; sb++) {
+        auto w = res->GetWaves(0, sb);
+        for (size_t i = 0; i < w.second; i++) {
+            anyTone = true;
+            // Sane band: amplitude index within table range (structurally
+            // guaranteed, but asserts the tone exists and is well-formed).
+            EXPECT_LE(w.first[i].AmpSf, 63u);
+            EXPECT_LE(w.first[i].FreqIndex, 1023u);
+        }
+    }
+    EXPECT_TRUE(anyTone) << "boundary tone must still be encoded (refined or analytic)";
+}
+
+// --- Option A: raw-2048-domain refit (ghawbrefine=1, MakeGhaProcessor0 arg 3) -
+
+// Count the total waves across all tone bands of channel 0.
+static size_t TotalWaves(const TAt3PGhaData& res) {
+    size_t n = 0;
+    for (int sb = 0; sb < res.NumToneBands; sb++) {
+        n += res.GetNumWaves(0, sb);
+    }
+    return n;
+}
+
+TEST(AT3PGHAWideband, RawRefineMatchesAnalyticStructureIsolatedTone) {
+    // A single clean tone is already well-fit; the raw-domain refit must not
+    // change which subbands it occupies or how many waves come out vs the
+    // subband-domain default. (Both modes are exercised on the same input.)
+    TWidebandPqfFixture fx;
+    GenWideband(2000.0f, 16384.0f, fx.Raw0, 2048);
+    GenWideband(2000.0f, 16384.0f, fx.Raw1, 2048);
+    fx.Run();
+
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    auto pB = MakeGhaProcessor0(false, true, 0);
+    auto rB = *pB->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+    auto pA = MakeGhaProcessor0(false, true, 1);
+    auto rA = *pA->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    EXPECT_EQ(rA.NumToneBands, rB.NumToneBands);
+    EXPECT_EQ(TotalWaves(rA), TotalWaves(rB)) << "raw-domain refit must not add or drop tones for a clean tone";
+    EXPECT_GT(rA.GetNumWaves(0, 1), 0u);
+}
+
+TEST(AT3PGHAWideband, RawRefineBoundaryToneNoBlowup) {
+    // Boundary tone (2756Hz) through the raw-domain refit: the joint Newton
+    // runs in the well-conditioned 2048 domain (no per-subband boundary
+    // ill-conditioning at all), and re-projection + the drift guard must keep
+    // every emitted wave well-formed -- no NaN/garbage magnitude, no abort.
+    TWidebandPqfFixture fx;
+    GenWideband(2756.0f, 14000.0f, fx.Raw0, 2048);
+    GenWideband(2756.0f, 14000.0f, fx.Raw1, 2048);
+    fx.Run();
+
+    auto proc = MakeGhaProcessor0(false, true, 1);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = proc->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    ASSERT_NE(res, nullptr);
+    bool anyTone = false;
+    for (int sb = 0; sb < res->NumToneBands; sb++) {
+        auto w = res->GetWaves(0, sb);
+        for (size_t i = 0; i < w.second; i++) {
+            anyTone = true;
+            EXPECT_LE(w.first[i].AmpSf, 63u);
+            EXPECT_LE(w.first[i].FreqIndex, 1023u);
+        }
+    }
+    EXPECT_TRUE(anyTone);
+}
+
+TEST(AT3PGHAWideband, RawRefineManyTonesStackSafe) {
+    // ~40 tones spread across the whole band in a single frame forces the
+    // raw-domain refit to run its batched joint Newton over multiple groups
+    // (batch size 6). The point is that it completes without a stack overflow
+    // from gha_adjust_info_newton_md's alloca (which would be ~5.5 MB for a
+    // single 40-tone solve at sz=2048 -- hence the batching). Reaching the
+    // assertions at all proves no crash; the counts just confirm it produced
+    // a sane, non-empty result under the shared 48-tone budget.
+    TWidebandPqfFixture fx;
+    int n = 0;
+    for (double f = 150.0; f < 10800.0; f += 260.0) {
+        GenWideband((float)f, 1500.0f, fx.Raw0, 2048);
+        GenWideband((float)f, 1500.0f, fx.Raw1, 2048);
+        n++;
+    }
+    ASSERT_GE(n, 35);
+    fx.Run();
+
+    auto proc = MakeGhaProcessor0(false, true, 1);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = proc->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    ASSERT_NE(res, nullptr);
+    EXPECT_GT(TotalWaves(*res), 0u);
+    EXPECT_LE(TotalWaves(*res), 48u) << "must respect the shared tone budget";
+}
+
+// ---- Normalized-amplitude regression tests --------------------------------
+//
+// The real encode pipeline feeds the GHA path PCM normalized to [-1, 1]
+// (libsndfile float reads), NOT the int16-range amplitudes the tests above use.
+// The psychoacoustic threshold (SubbandAth) is calibrated for that range, so
+// these tests exercise the actual near-threshold detection regime rather than a
+// saturated one. Amplitudes here are ~0.5 full-scale.
+
+// A single normalized sparse tone must be detected in its home PQF subband.
+// Home subband = floor(freqHz / 1378.125): 5000->3, 8000->5, 10000->7.
+static void CheckNormalizedIsolatedTone(float freqHz, int homeSb) {
+    TWidebandPqfFixture fx;
+    GenWideband(freqHz, 0.5f, fx.Raw0, 2048);
+    GenWideband(freqHz, 0.5f, fx.Raw1, 2048);
+    fx.Run();
+
+    auto proc = MakeGhaProcessor0(false, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = proc->DoAnalize({fx.Pqf0, fx.Pqf1}, {nullptr, nullptr}, w1, w2, fx.Raw0, nullptr);
+
+    ASSERT_NE(res, nullptr) << freqHz << "Hz normalized tone must be detected";
+    ASSERT_GT(res->NumToneBands, homeSb) << "home subband must be within the used range";
+    EXPECT_GT(res->GetNumWaves(0, homeSb), 0u) << freqHz << "Hz must land in its home subband " << homeSb;
+}
+
+TEST(AT3PGHAWideband, NormalizedSparseTone5kHz)  { CheckNormalizedIsolatedTone(5000.0f, 3); }
+TEST(AT3PGHAWideband, NormalizedSparseTone8kHz)  { CheckNormalizedIsolatedTone(8000.0f, 5); }
+TEST(AT3PGHAWideband, NormalizedSparseTone10kHz) { CheckNormalizedIsolatedTone(10000.0f, 7); }
+
+// Follower-channel fairness at normalized amplitudes: a dense left channel must
+// not consume the whole shared 48-tone budget and starve a clean, isolated
+// right-channel tone (this is what the round-robin extraction fairness exists
+// to prevent). Assert the follower channel actually carries tone(s), not just
+// that the combined count stays under budget.
+TEST(AT3PGHAWideband, NormalizedDenseLeftSparseRightFollowerGetsTones) {
+    TWidebandPqfFixture left, right;
+    int n = 0;
+    for (double f = 150.0; f < 10800.0; f += 200.0) { // dense, spans the band
+        GenWideband((float)f, 0.06f, left.Raw0, 2048);
+        GenWideband((float)f, 0.06f, left.Raw1, 2048);
+        n++;
+    }
+    ASSERT_GE(n, 40);
+    GenWideband(3000.0f, 0.5f, right.Raw0, 2048); // one clean tone, well above the left floor
+    GenWideband(3000.0f, 0.5f, right.Raw1, 2048);
+    left.Run();
+    right.Run();
+
+    auto proc = MakeGhaProcessor0(true, true);
+    float w1[2048] = {0};
+    float w2[2048] = {0};
+    const auto* res = proc->DoAnalize({left.Pqf0, left.Pqf1}, {right.Pqf0, right.Pqf1}, w1, w2, left.Raw0, right.Raw0);
+
+    ASSERT_NE(res, nullptr);
+    size_t leaderWaves = 0, followerWaves = 0;
+    for (int sb = 0; sb < res->NumToneBands; sb++) {
+        leaderWaves += res->GetNumWaves(0, sb);
+        followerWaves += res->GetNumWaves(1, sb);
+    }
+    EXPECT_GT(leaderWaves, 0u);
+    EXPECT_GT(followerWaves, 0u) << "the sparse right channel must not be starved by the dense left channel";
+    EXPECT_LE(leaderWaves + followerWaves, 48u) << "must respect the shared tone budget";
+}
diff --git a/src/atrac/at3p/at3p_pqf_wideband_table.h b/src/atrac/at3p/at3p_pqf_wideband_table.h
new file mode 100644
index 0000000..d8fba2d
--- /dev/null
+++ b/src/atrac/at3p/at3p_pqf_wideband_table.h
@@ -0,0 +1,6435 @@
+/* GENERATED FILE. See src/atrac/at3p/tools/pqf_wideband_calibrate.cpp */
+#pragma once
+
+#include <cstddef>
+
+namespace NAtracDEnc {
+
+struct TPqfWidebandPoint {
+    float FreqHz;
+    float Magnitude, Phase, Omega;
+};
+
+constexpr size_t PqfWidebandTableSize = 798;
+constexpr size_t PqfWidebandSubbands = 8;
+
+static const TPqfWidebandPoint PqfWidebandTable0[] = {
+    { 1.0f, 34175.8516f, 3.45275776f, 0.00167644048f },
+    { 2.0f, 32733.9873f, 2.99942425f, 0.00465637357f },
+    { 3.0f, 32784.5483f, 3.07447114f, 0.00683822543f },
+    { 4.0f, 32743.4846f, 3.04465262f, 0.00912952742f },
+    { 5.0f, 32762.8347f, 3.03374035f, 0.0113983258f },
+    { 6.0f, 32748.5049f, 3.01027995f, 0.013680591f },
+    { 7.0f, 32757.1597f, 2.99142714f, 0.0159575807f },
+    { 8.0f, 32750.2838f, 2.96944631f, 0.0182379518f },
+    { 9.0f, 32754.8683f, 2.94884265f, 0.0205167651f },
+    { 10.0f, 32751.0937f, 2.92732306f, 0.0227965629f },
+    { 11.0f, 32753.7279f, 2.90617111f, 0.0250759475f },
+    { 12.0f, 32751.5203f, 2.88481334f, 0.0273555441f },
+    { 13.0f, 32753.0866f, 2.86345941f, 0.0296351366f },
+    { 14.0f, 32751.7649f, 2.84215579f, 0.0319146626f },
+    { 15.0f, 32752.6972f, 2.820724f, 0.0341943322f },
+    { 20.0f, 32752.0549f, 2.71388717f, 0.0455922626f },
+    { 40.0f, 32752.0385f, 2.285318f, 0.0911845513f },
+    { 60.0f, 32751.9947f, 1.85506242f, 0.136776821f },
+    { 80.0f, 32752.0004f, 1.4223044f, 0.182369097f },
+    { 100.0f, 32751.9923f, 0.986301487f, 0.227961372f },
+    { 120.0f, 32751.9906f, 0.546379216f, 0.273553646f },
+    { 140.0f, 32751.9885f, 0.101952054f, 0.319145921f },
+    { 160.0f, 32751.9903f, 5.93572839f, 0.364738195f },
+    { 180.0f, 32751.9941f, 5.48098133f, 0.410330469f },
+    { 200.0f, 32751.9971f, 5.02067324f, 0.455922743f },
+    { 220.0f, 32751.9979f, 4.55472094f, 0.501515018f },
+    { 240.0f, 32751.9952f, 4.0831809f, 0.547107292f },
+    { 260.0f, 32751.9918f, 3.60624501f, 0.592699566f },
+    { 280.0f, 32751.9897f, 3.12422795f, 0.638291841f },
+    { 300.0f, 32751.9906f, 2.63755228f, 0.683884115f },
+    { 320.0f, 32751.9934f, 2.14672405f, 0.729476389f },
+    { 340.0f, 32751.9957f, 1.65231084f, 0.775068664f },
+    { 360.0f, 32751.9961f, 1.15491397f, 0.820660938f },
+    { 380.0f, 32751.9938f, 0.655142419f, 0.866253212f },
+    { 400.0f, 32751.9913f, 0.153586639f, 0.911845487f },
+    { 420.0f, 32751.9901f, 5.93397968f, 0.957437761f },
+    { 440.0f, 32751.9919f, 5.43043596f, 1.00303004f },
+    { 460.0f, 32751.9941f, 4.9265456f, 1.04862231f },
+    { 480.0f, 32751.9946f, 4.42262289f, 1.09421458f },
+    { 500.0f, 32751.9925f, 3.9188863f, 1.13980686f },
+    { 520.0f, 32751.9883f, 3.4154603f, 1.18539913f },
+    { 540.0f, 32751.9851f, 2.91238497f, 1.23099141f },
+    { 560.0f, 32751.9855f, 2.40963011f, 1.27658368f },
+    { 580.0f, 32751.9894f, 1.90711571f, 1.32217596f },
+    { 600.0f, 32751.994f, 1.40473318f, 1.36776823f },
+    { 620.0f, 32751.9951f, 0.902367113f, 1.4133605f },
+    { 640.0f, 32751.9903f, 0.399915625f, 1.45895278f },
+    { 660.0f, 32751.9812f, 6.18048912f, 1.50454505f },
+    { 680.0f, 32751.9731f, 5.67767867f, 1.55013733f },
+    { 700.0f, 32751.9712f, 5.17466955f, 1.5957296f },
+    { 720.0f, 32751.9776f, 4.67149583f, 1.64132188f },
+    { 740.0f, 32751.9885f, 4.1682149f, 1.68691415f },
+    { 760.0f, 32751.9951f, 3.66489932f, 1.73250642f },
+    { 780.0f, 32751.991f, 3.16161733f, 1.7780987f },
+    { 800.0f, 32751.9759f, 2.65842591f, 1.82369097f },
+    { 820.0f, 32751.9578f, 2.15536003f, 1.86928325f },
+    { 840.0f, 32751.9499f, 1.65242941f, 1.91487552f },
+    { 860.0f, 32751.9593f, 1.14961778f, 1.9604678f },
+    { 880.0f, 32751.9805f, 0.646889744f, 2.00606007f },
+    { 900.0f, 32751.9941f, 0.144196918f, 2.05165235f },
+    { 920.0f, 32751.9812f, 5.92467421f, 2.09724462f },
+    { 940.0f, 32751.9391f, 5.42190775f, 2.14283689f },
+    { 960.0f, 32751.9009f, 4.91905427f, 2.18842917f },
+    { 980.0f, 32751.9198f, 4.41610321f, 2.23402144f },
+    { 1000.0f, 32751.9897f, 3.91306487f, 2.27961372f },
+    { 1020.0f, 32751.8721f, 3.40996438f, 2.32520599f },
+    { 1040.0f, 32750.798f, 2.90683842f, 2.37079827f },
+    { 1060.0f, 32747.0417f, 2.40372651f, 2.41639054f },
+    { 1080.0f, 32737.3848f, 1.90066243f, 2.46198281f },
+    { 1100.0f, 32716.5171f, 1.39766987f, 2.50757509f },
+    { 1120.0f, 32676.4556f, 0.894755982f, 2.55316736f },
+    { 1140.0f, 32606.085f, 0.391913362f, 2.59875964f },
+    { 1160.0f, 32490.9308f, 6.17230567f, 2.64435191f },
+    { 1180.0f, 32313.2706f, 5.66953188f, 2.68994419f },
+    { 1200.0f, 32052.6582f, 5.1667444f, 2.73553646f },
+    { 1220.0f, 31686.8955f, 4.66391373f, 2.78112873f },
+    { 1240.0f, 31193.4113f, 4.16101982f, 2.82672101f },
+    { 1260.0f, 30550.9778f, 3.65805317f, 2.87231328f },
+    { 1280.0f, 29741.5782f, 3.15501789f, 2.91790556f },
+    { 1300.0f, 28752.2962f, 2.651929f, 2.96349783f },
+    { 1320.0f, 27576.9179f, 2.1488089f, 3.00909011f },
+    { 1340.0f, 26217.2508f, 1.64569098f, 3.05468238f },
+    { 1360.0f, 24683.6712f, 1.14251298f, 3.10027475f },
+    { 1363.125f, 24429.5338f, 1.06403024f, 3.10739841f },
+    { 1364.125f, 24347.6937f, 1.03866037f, 3.10967826f },
+    { 1365.125f, 24265.1401f, 1.01376016f, 3.11195759f },
+    { 1366.125f, 24182.395f, 0.988259372f, 3.11423759f },
+    { 1367.125f, 24099.5517f, 0.963510483f, 3.11651675f },
+    { 1368.125f, 24015.6387f, 0.937802393f, 3.11879698f },
+    { 1369.125f, 23933.2249f, 0.913292661f, 3.12107587f },
+    { 1370.125f, 23847.4588f, 0.88724206f, 3.12335649f },
+    { 1371.125f, 23767.5803f, 0.863115572f, 3.12563492f },
+    { 1372.125f, 23677.8849f, 0.836477315f, 3.12791623f },
+    { 1373.125f, 23608.8233f, 0.812864291f, 3.13019401f },
+    { 1374.125f, 23506.8745f, 0.785362087f, 3.13247641f },
+    { 1375.125f, 23507.0188f, 0.759546415f, 3.13475606f },
+    { 1376.125f, 23332.937f, 0.73866517f, 3.13703307f },
+    { 1377.125f, 23243.5541f, 1.190092f, 3.13702342f },
+    { 1378.125f, 23154.1713f, 1.64151883f, 3.13701377f },
+    { 1379.125f, 23064.7884f, 2.09294566f, 3.13700411f },
+    { 1380.0f, 22986.5784f, 2.48794413f, 3.13699567f },
+    { 1380.125f, 22975.4055f, 2.54437249f, 3.13699446f },
+    { 1381.125f, 22819.9389f, 2.534212f, 3.1347517f },
+    { 1382.125f, 22803.9189f, 2.56186683f, 3.1324677f },
+    { 1383.125f, 22705.0958f, 2.58059726f, 3.13019505f },
+    { 1384.125f, 22627.7268f, 2.60807148f, 3.12791261f },
+    { 1385.125f, 22536.413f, 2.63077384f, 3.12563567f },
+    { 1386.125f, 22449.4362f, 2.65715683f, 3.12335461f },
+    { 1387.125f, 22359.4371f, 2.68112426f, 3.12107629f },
+    { 1388.125f, 22269.6518f, 2.70694789f, 3.1187959f },
+    { 1389.125f, 22179.5761f, 2.73146524f, 3.11651698f },
+    { 1390.125f, 22088.5704f, 2.75699036f, 3.11423693f },
+    { 1391.125f, 21998.0226f, 2.78178768f, 3.1119577f },
+    { 1392.125f, 21906.2888f, 2.80714318f, 3.10967784f },
+    { 1393.125f, 21815.152f, 2.83209721f, 3.10739844f },
+    { 1400.0f, 21178.0224f, 3.00494839f, 3.0917261f },
+    { 1420.0f, 19266.365f, 3.50778658f, 3.04613382f },
+    { 1440.0f, 17297.7687f, 4.01051917f, 3.00054156f },
+    { 1460.0f, 15312.8139f, 4.5131789f, 2.95494928f },
+    { 1480.0f, 13352.1645f, 5.01578525f, 2.90935701f },
+    { 1500.0f, 11454.5057f, 5.51838447f, 2.86376473f },
+    { 1520.0f, 9654.58192f, 6.02103813f, 2.81817246f },
+    { 1540.0f, 7981.7045f, 0.240636699f, 2.77258018f },
+    { 1560.0f, 6458.7164f, 0.743637639f, 2.72698791f },
+    { 1580.0f, 5101.47772f, 1.24695296f, 2.68139563f },
+    { 1600.0f, 3918.81493f, 1.75068499f, 2.63580336f },
+    { 1620.0f, 2912.87039f, 2.25493958f, 2.59021109f },
+    { 1640.0f, 2079.7543f, 2.75982256f, 2.54461881f },
+    { 1660.0f, 1410.40421f, 3.26543966f, 2.49902654f },
+    { 1680.0f, 891.56257f, 3.77188852f, 2.45343426f },
+    { 1700.0f, 506.804066f, 4.27923811f, 2.40784199f },
+    { 1720.0f, 237.563457f, 4.78735932f, 2.36224971f },
+    { 1740.0f, 64.1315559f, 5.29367295f, 2.31665744f },
+    { 1760.0f, 33.4068542f, 2.68230257f, 2.27106517f },
+    { 1780.0f, 74.2806348f, 3.19269776f, 2.22547289f },
+    { 1800.0f, 76.2776153f, 3.71624758f, 2.17988062f },
+    { 1820.0f, 55.0686759f, 4.25993065f, 2.13428834f },
+    { 1840.0f, 23.8329128f, 4.89908422f, 2.08869607f },
+    { 1860.0f, 9.93701676f, 1.52514443f, 2.04310379f },
+    { 1880.0f, 34.1835177f, 2.4329618f, 1.99751152f },
+    { 1900.0f, 48.9517739f, 3.00455841f, 1.95191924f },
+    { 1920.0f, 52.3670593f, 3.54837664f, 1.90632697f },
+    { 1940.0f, 45.5406907f, 4.09375702f, 1.8607347f },
+    { 1960.0f, 31.2443898f, 4.6666979f, 1.81514242f },
+    { 1980.0f, 13.3931643f, 5.40043322f, 1.76955015f },
+    { 2000.0f, 7.73530772f, 1.74604242f, 1.72395787f },
+    { 2020.0f, 22.1048221f, 2.72025414f, 1.6783656f },
+    { 2040.0f, 32.044176f, 3.31893349f, 1.63277332f },
+    { 2060.0f, 35.5764948f, 3.87586508f, 1.58718105f },
+    { 2080.0f, 32.7516779f, 4.43043725f, 1.54158878f },
+    { 2100.0f, 24.7965181f, 5.00937332f, 1.4959965f },
+    { 2120.0f, 13.8727523f, 5.6947893f, 1.45040422f },
+    { 2140.0f, 4.86897658f, 0.99166106f, 1.40481195f },
+    { 2160.0f, 11.1631294f, 2.81208809f, 1.35921968f },
+    { 2180.0f, 18.438404f, 3.53297751f, 1.3136274f },
+    { 2200.0f, 21.8516269f, 4.13245708f, 1.26803513f },
+    { 2220.0f, 20.9770098f, 4.71780186f, 1.22244286f },
+    { 2240.0f, 16.4547294f, 5.33775796f, 1.17685058f },
+    { 2260.0f, 9.84648239f, 6.11112589f, 1.13125831f },
+    { 2280.0f, 5.20587674f, 1.33806989f, 1.08566603f },
+    { 2300.0f, 8.84508973f, 2.86146362f, 1.04007376f },
+    { 2320.0f, 13.3675626f, 3.64446781f, 0.994481487f },
+    { 2340.0f, 15.2775869f, 4.27928252f, 0.94888921f },
+    { 2360.0f, 14.0444475f, 4.89560588f, 0.903296935f },
+    { 2380.0f, 10.1411596f, 5.57592489f, 0.857704661f },
+    { 2400.0f, 5.25457727f, 0.334651017f, 0.812112387f },
+    { 2420.0f, 5.47759574f, 2.2079286f, 0.766520115f },
+    { 2440.0f, 10.2407378f, 3.19728654f, 0.720927837f },
+    { 2460.0f, 13.7873493f, 3.85697909f, 0.675335564f },
+    { 2480.0f, 14.7200303f, 4.4475359f, 0.629743293f },
+    { 2500.0f, 12.7524879f, 5.03220625f, 0.584151015f },
+    { 2520.0f, 8.33031145f, 5.67881089f, 0.538558741f },
+    { 2540.0f, 3.072809f, 0.587249067f, 0.492966453f },
+    { 2560.0f, 5.49873245f, 2.79666084f, 0.44737419f },
+    { 2580.0f, 10.8427805f, 3.5640864f, 0.401781918f },
+    { 2600.0f, 14.3514862f, 4.15157113f, 0.356189643f },
+    { 2620.0f, 15.1083275f, 4.70394037f, 0.310597369f },
+    { 2640.0f, 12.914338f, 5.25562366f, 0.265005095f },
+    { 2660.0f, 8.20675684f, 5.85052048f, 0.219412821f },
+    { 2680.0f, 2.3078091f, 0.66192613f, 0.173820548f },
+    { 2700.0f, 5.37810005f, 3.23740173f, 0.128228272f },
+    { 2720.0f, 11.067913f, 3.91244725f, 0.0826360015f },
+    { 2740.0f, 14.7506037f, 4.47060195f, 0.0370435725f },
+    { 2741.25f, 14.8920567f, 4.50448612f, 0.034194089f },
+    { 2742.25f, 14.9976184f, 4.53158299f, 0.0319144749f },
+    { 2743.25f, 15.0948374f, 4.55865346f, 0.0296348477f },
+    { 2744.25f, 15.1859855f, 4.58580481f, 0.0273551086f },
+    { 2745.25f, 15.2681061f, 4.61272262f, 0.0250755963f },
+    { 2746.25f, 15.344839f, 4.64007776f, 0.022795585f },
+    { 2747.25f, 15.4114607f, 4.66671336f, 0.0205163597f },
+    { 2748.25f, 15.473912f, 4.69468802f, 0.018235647f },
+    { 2749.25f, 15.524643f, 4.7206956f, 0.0159571485f },
+    { 2750.25f, 15.5732289f, 4.75059737f, 0.0136743767f },
+    { 2751.25f, 15.607832f, 4.77491228f, 0.0113980032f },
+    { 2752.25f, 15.6438611f, 4.81309197f, 0.00910660447f },
+    { 2753.25f, 15.6672726f, 4.83180039f, 0.00683861891f },
+    { 2754.25f, 15.6557638f, 4.76600659f, 0.00683890724f },
+    { 2755.25f, 15.644255f, 4.70021279f, 0.00683919557f },
+    { 2756.25f, 15.6327461f, 4.63441899f, 0.0068394839f },
+    { 2757.25f, 15.6212373f, 4.56862519f, 0.00683977223f },
+    { 2758.25f, 15.6097285f, 4.50283139f, 0.00684006056f },
+    { 2759.25f, 15.5982196f, 4.4370376f, 0.00684034888f },
+    { 2760.0f, 15.6023219f, 4.41516878f, 0.00855057415f },
+    { 2760.25f, 15.6075515f, 4.41752174f, 0.00911012656f },
+    { 2761.25f, 15.556159f, 4.3828336f, 0.0113976019f },
+    { 2762.25f, 15.5200579f, 4.35694615f, 0.0136758309f },
+    { 2763.25f, 15.4612083f, 4.32857455f, 0.0159568602f },
+    { 2764.25f, 15.4036405f, 4.30162289f, 0.018236402f },
+    { 2765.25f, 15.3322435f, 4.27441793f, 0.0205161971f },
+    { 2766.25f, 15.257453f, 4.24720536f, 0.0227960155f },
+    { 2767.25f, 15.1721705f, 4.22024032f, 0.0250755166f },
+    { 2768.25f, 15.0815161f, 4.19294058f, 0.0273553719f },
+    { 2769.25f, 14.9819824f, 4.16598535f, 0.0296348029f },
+    { 2770.25f, 14.8761224f, 4.13863268f, 0.0319146422f },
+    { 2771.25f, 14.7622625f, 4.11159309f, 0.0341940822f },
+    { 2780.0f, 13.4679639f, 3.87117619f, 0.0541408052f },
+    { 2800.0f, 8.75517107f, 3.28253911f, 0.0997331086f },
+    { 2820.0f, 2.73868506f, 2.28176471f, 0.145325375f },
+    { 2840.0f, 5.07521329f, 5.94172381f, 0.190917645f },
+    { 2860.0f, 10.8933033f, 5.23575734f, 0.236509923f },
+    { 2880.0f, 14.7783152f, 4.67005311f, 0.282102197f },
+    { 2900.0f, 15.8850111f, 4.12536447f, 0.327694472f },
+    { 2920.0f, 14.0142668f, 3.57397516f, 0.373286743f },
+    { 2940.0f, 9.59255109f, 2.97714255f, 0.418879021f },
+    { 2960.0f, 3.81470987f, 2.07740578f, 0.464471292f },
+    { 2980.0f, 4.18044171f, 5.85536167f, 0.510063575f },
+    { 3000.0f, 9.69312378f, 5.00824142f, 0.555655843f },
+    { 3020.0f, 13.5583793f, 4.40842701f, 0.601248117f },
+    { 3040.0f, 14.8173442f, 3.84161125f, 0.646840393f },
+    { 3060.0f, 13.2680986f, 3.26483651f, 0.692432667f },
+    { 3080.0f, 9.3495389f, 2.62387039f, 0.738024941f },
+    { 3100.0f, 4.40949139f, 1.63850423f, 0.783617215f },
+    { 3120.0f, 4.439996f, 5.83832629f, 0.82920949f },
+    { 3140.0f, 9.12413507f, 4.8627296f, 0.874801766f },
+    { 3160.0f, 12.5898651f, 4.21230205f, 0.920394038f },
+    { 3180.0f, 13.6973627f, 3.6143581f, 0.965986312f },
+    { 3200.0f, 12.2356558f, 3.00631523f, 1.01157859f },
+    { 3220.0f, 8.66107357f, 2.31361278f, 1.05717086f },
+    { 3240.0f, 4.53573473f, 1.21123488f, 1.10276314f },
+    { 3260.0f, 5.20644879f, 5.67459388f, 1.14835541f },
+    { 3280.0f, 9.46220062f, 4.7114125f, 1.19394768f },
+    { 3300.0f, 12.7333523f, 4.04016594f, 1.23953996f },
+    { 3320.0f, 13.8919732f, 3.42902254f, 1.28513223f },
+    { 3340.0f, 12.6980416f, 2.81587758f, 1.33072451f },
+    { 3360.0f, 9.51096077f, 2.14042025f, 1.37631678f },
+    { 3380.0f, 5.46807002f, 1.20035514f, 1.42190906f },
+    { 3400.0f, 4.37136478f, 5.77615927f, 1.46750133f },
+    { 3420.0f, 7.85830922f, 4.59462888f, 1.5130936f },
+    { 3440.0f, 11.2244838f, 3.85648921f, 1.55868588f },
+    { 3460.0f, 12.9855918f, 3.21400428f, 1.60427815f },
+    { 3480.0f, 12.8156517f, 2.58428401f, 1.64987043f },
+    { 3500.0f, 10.916895f, 1.92166444f, 1.6954627f },
+    { 3520.0f, 7.94477046f, 1.15271122f, 1.74105498f },
+    { 3540.0f, 5.20752805f, 0.0873705059f, 1.78664725f },
+    { 3560.0f, 4.96350593f, 4.95978027f, 1.83223952f },
+    { 3580.0f, 6.88144132f, 3.87108729f, 1.8778318f },
+    { 3600.0f, 8.68317856f, 3.0502984f, 1.92342407f },
+    { 3620.0f, 9.59185958f, 2.30614268f, 1.96901635f },
+    { 3640.0f, 9.58593313f, 1.56651225f, 2.01460862f },
+    { 3660.0f, 8.92407117f, 0.801110361f, 2.0602009f },
+    { 3680.0f, 7.9070429f, 6.28057019f, 2.10579317f },
+    { 3700.0f, 6.72020241f, 5.43123157f, 2.15138545f },
+    { 3720.0f, 5.45400218f, 4.50688992f, 2.19697772f },
+    { 3740.0f, 4.40998021f, 3.42155905f, 2.24257001f },
+    { 3760.0f, 4.43502775f, 2.17281113f, 2.28816226f },
+    { 3780.0f, 5.86215494f, 1.0855964f, 2.33375454f },
+    { 3800.0f, 7.75684234f, 0.248480894f, 2.37934682f },
+    { 3820.0f, 9.19135396f, 5.83394466f, 2.42493909f },
+    { 3840.0f, 9.56025963f, 5.20624282f, 2.47053137f },
+    { 3860.0f, 8.53919062f, 4.61278147f, 2.51612364f },
+    { 3880.0f, 6.1045845f, 4.02254787f, 2.56171591f },
+    { 3900.0f, 2.57500671f, 3.31281569f, 2.60730819f },
+    { 3920.0f, 1.90555778f, 0.361815565f, 2.65290046f },
+    { 3940.0f, 5.90294165f, 5.85391525f, 2.69849273f },
+    { 3960.0f, 9.14130388f, 5.30751761f, 2.74408501f },
+    { 3980.0f, 10.8995027f, 4.80223106f, 2.78967728f },
+    { 4000.0f, 10.7744275f, 4.32153285f, 2.83526956f },
+    { 4020.0f, 8.71529817f, 3.87456052f, 2.88086184f },
+    { 4040.0f, 5.08986058f, 3.52962713f, 2.92645411f },
+    { 4060.0f, 1.61361244f, 4.24736637f, 2.97204638f },
+    { 4080.0f, 5.0620122f, 5.0734235f, 3.01763866f },
+    { 4100.0f, 9.04092739f, 4.7513969f, 3.06323095f },
+    { 4119.375f, 11.4634484f, 4.3480983f, 3.10739844f },
+    { 4120.0f, 11.5108978f, 4.33471543f, 3.10882318f },
+    { 4120.375f, 11.5384618f, 4.32645503f, 3.10967828f },
+    { 4121.375f, 11.6077652f, 4.30520087f, 3.11195764f },
+    { 4122.375f, 11.6720774f, 4.28335181f, 3.11423764f },
+    { 4123.375f, 11.7306717f, 4.26223304f, 3.11651681f },
+    { 4124.375f, 11.7839899f, 4.24008469f, 3.11879711f },
+    { 4125.375f, 11.8320064f, 4.21922396f, 3.12107595f },
+    { 4126.375f, 11.8739828f, 4.19653217f, 3.12335683f },
+    { 4127.375f, 11.9121313f, 4.17620081f, 3.12563502f },
+    { 4128.375f, 11.9419442f, 4.15230002f, 3.12791723f },
+    { 4129.375f, 11.9737249f, 4.13300897f, 3.1301941f },
+    { 4130.375f, 11.9879258f, 4.10532397f, 3.13248042f },
+    { 4131.375f, 12.0405388f, 4.08616864f, 3.13475584f },
+    { 4132.375f, 12.0155246f, 4.02956381f, 3.13707305f },
+    { 4133.375f, 12.0081924f, 4.38185025f, 3.13706368f },
+    { 4134.375f, 12.0008603f, 4.73413669f, 3.13705431f },
+    { 4135.375f, 11.9935282f, 5.08642313f, 3.13704494f },
+    { 4136.375f, 11.986196f, 5.43870957f, 3.13703558f },
+    { 4137.375f, 11.9211836f, 5.46629591f, 3.13475142f },
+    { 4138.375f, 11.9398765f, 5.48657328f, 3.13247233f },
+    { 4139.375f, 11.9002855f, 5.50585126f, 3.13019517f },
+    { 4140.0f, 11.8816172f, 5.51854422f, 3.12877105f },
+    { 4140.375f, 11.8717782f, 5.5285516f, 3.12791386f },
+    { 4141.375f, 11.8268306f, 5.54841052f, 3.12563581f },
+    { 4142.375f, 11.7811732f, 5.57056624f, 3.12335507f },
+    { 4143.375f, 11.7265947f, 5.59084392f, 3.12107641f },
+    { 4144.375f, 11.6680854f, 5.61253154f, 3.11879609f },
+    { 4145.375f, 11.6029463f, 5.63299118f, 3.11651708f },
+    { 4146.375f, 11.5327846f, 5.65432355f, 3.11423701f },
+    { 4147.375f, 11.4568735f, 5.67484022f, 3.11195778f },
+    { 4148.375f, 11.3755234f, 5.69586806f, 3.10967788f },
+    { 4149.375f, 11.2888334f, 5.71634085f, 3.1073985f },
+    { 4160.0f, 10.044759f, 5.92905766f, 3.08317753f },
+    { 4180.0f, 6.37297709f, 6.24354465f, 3.03758527f },
+    { 4200.0f, 2.50558709f, 5.84618326f, 2.991993f },
+    { 4220.0f, 5.15290282f, 4.88282222f, 2.94640073f },
+    { 4240.0f, 9.50987672f, 5.11337173f, 2.90080845f },
+    { 4260.0f, 12.396661f, 5.50014448f, 2.85521618f },
+    { 4280.0f, 13.0621735f, 5.91490638f, 2.80962391f },
+    { 4300.0f, 11.3326388f, 0.0342417386f, 2.76403163f },
+    { 4320.0f, 7.59602025f, 0.359081171f, 2.71843936f },
+    { 4340.0f, 3.26383868f, 0.190283869f, 2.67284708f },
+    { 4360.0f, 4.7412384f, 5.39157817f, 2.62725481f },
+    { 4380.0f, 9.20906055f, 5.52827208f, 2.58166253f },
+    { 4400.0f, 12.3132215f, 5.88771833f, 2.53607026f },
+    { 4420.0f, 13.1752381f, 0.000245051192f, 2.49047799f },
+    { 4440.0f, 11.6232252f, 0.379326902f, 2.44488571f },
+    { 4460.0f, 8.11442078f, 0.663846355f, 2.39929343f },
+    { 4480.0f, 4.26637602f, 0.500251589f, 2.35370116f },
+    { 4500.0f, 5.25385053f, 5.99127785f, 2.30810889f },
+    { 4520.0f, 9.2744065f, 6.04488718f, 2.26251661f },
+    { 4540.0f, 12.1882328f, 0.0795155672f, 2.21692434f },
+    { 4560.0f, 12.957304f, 0.448414698f, 2.17133207f },
+    { 4580.0f, 11.4057321f, 0.800260753f, 2.12573979f },
+    { 4600.0f, 8.04888011f, 1.04055784f, 2.08014752f },
+    { 4620.0f, 4.7372081f, 0.822957118f, 2.03455524f },
+    { 4640.0f, 6.0301216f, 0.20999484f, 1.98896297f },
+    { 4660.0f, 9.9029583f, 0.274927109f, 1.94337069f },
+    { 4680.0f, 12.8059343f, 0.582263104f, 1.89777842f },
+    { 4700.0f, 13.6992145f, 0.946689797f, 1.85218615f },
+    { 4720.0f, 12.3723402f, 1.30563199f, 1.80659387f },
+    { 4740.0f, 9.22155804f, 1.59014384f, 1.7610016f },
+    { 4760.0f, 5.51009908f, 1.57942932f, 1.71540932f },
+    { 4780.0f, 4.96630987f, 0.950374186f, 1.66981704f },
+    { 4800.0f, 8.3059103f, 0.824021069f, 1.62422477f },
+    { 4820.0f, 11.4691541f, 1.07357067f, 1.5786325f },
+    { 4840.0f, 13.0811439f, 1.41699336f, 1.53304023f },
+    { 4860.0f, 12.8172788f, 1.77666733f, 1.48744795f },
+    { 4880.0f, 10.8604088f, 2.10868299f, 1.44185568f },
+    { 4900.0f, 7.81803173f, 2.34204924f, 1.3962634f },
+    { 4920.0f, 4.92705016f, 2.2733033f, 1.35067113f },
+    { 4940.0f, 4.63236759f, 1.79092976f, 1.30507886f },
+    { 4960.0f, 6.75424565f, 1.6837474f, 1.25948658f },
+    { 4980.0f, 8.78039209f, 1.88094428f, 1.2138943f },
+    { 5000.0f, 9.84868575f, 2.17040312f, 1.16830203f },
+    { 5020.0f, 9.82107581f, 2.4822533f, 1.12270975f },
+    { 5040.0f, 8.82796828f, 2.78531754f, 1.07711748f },
+    { 5060.0f, 7.12700245f, 3.05056944f, 1.03152521f },
+    { 5080.0f, 5.07133507f, 3.21619952f, 0.985932926f },
+    { 5100.0f, 3.29960592f, 3.09896336f, 0.940340658f },
+    { 5120.0f, 3.18918838f, 2.62362873f, 0.894748377f },
+    { 5140.0f, 4.72101185f, 2.50734892f, 0.849156103f },
+    { 5160.0f, 6.39353f, 2.71279114f, 0.803563836f },
+    { 5180.0f, 7.50852266f, 3.04543819f, 0.757971561f },
+    { 5200.0f, 7.75398132f, 3.43995611f, 0.712379287f },
+    { 5220.0f, 7.00476842f, 3.87245933f, 0.666787012f },
+    { 5240.0f, 5.30684053f, 4.33237689f, 0.621194736f },
+    { 5260.0f, 2.86925271f, 4.81583653f, 0.575602476f },
+    { 5280.0f, 2.82982753f, 3.74075085f, 0.530010195f },
+    { 5300.0f, 2.79040234f, 2.66566517f, 0.484417915f },
+    { 5320.0f, 5.1811676f, 3.19576232f, 0.438825641f },
+    { 5340.0f, 6.79203603f, 3.7370441f, 0.393233365f },
+    { 5360.0f, 7.39961329f, 4.29330239f, 0.347641093f },
+    { 5380.0f, 6.94007726f, 4.87041581f, 0.302048822f },
+    { 5400.0f, 5.5200684f, 5.48551601f, 0.256456543f },
+    { 5420.0f, 3.42627425f, 6.20879623f, 0.210864254f },
+    { 5440.0f, 1.45394943f, 1.27925233f, 0.165271997f },
+    { 5460.0f, 2.48423258f, 3.22506916f, 0.119679725f },
+    { 5480.0f, 4.53761472f, 4.07083862f, 0.0740874326f },
+    { 5497.5f, 5.88169112f, 4.64628659f, 0.0341941118f },
+    { 5498.5f, 5.93975835f, 4.67763368f, 0.0319144295f },
+    { 5499.5f, 5.99510676f, 4.70874274f, 0.0296348775f },
+    { 5500.0f, 6.02229437f, 4.72421611f, 0.0284951492f },
+    { 5500.5f, 6.04876273f, 4.73998492f, 0.0273550474f },
+    { 5501.5f, 6.09944941f, 4.77072981f, 0.0250756638f },
+    { 5502.5f, 6.14855426f, 4.80209375f, 0.0227954871f },
+    { 5503.5f, 6.194471f, 4.83233928f, 0.0205164632f },
+    { 5504.5f, 6.23901071f, 4.86420655f, 0.0182355418f },
+    { 5505.5f, 6.28019421f, 4.89361532f, 0.0159573163f },
+    { 5506.5f, 6.32004103f, 4.92724163f, 0.0136743407f },
+    { 5507.5f, 6.35721394f, 4.95482094f, 0.0113982247f },
+    { 5508.5f, 6.39199338f, 4.99580557f, 0.00910736887f },
+    { 5509.5f, 6.43291614f, 5.01922387f, 0.0068378038f },
+    { 5510.5f, 6.45049592f, 4.88757677f, 0.00683833137f },
+    { 5511.5f, 6.4680757f, 4.75592966f, 0.00683885894f },
+    { 5512.5f, 6.48565547f, 4.62428256f, 0.00683938651f },
+    { 5513.5f, 6.50323525f, 4.49263546f, 0.00683991408f },
+    { 5514.5f, 6.52081503f, 4.36098835f, 0.00684044165f },
+    { 5515.5f, 6.53839481f, 4.22934125f, 0.00684096921f },
+    { 5516.5f, 6.5752203f, 4.20457268f, 0.00911425971f },
+    { 5517.5f, 6.58128713f, 4.17103172f, 0.0113974863f },
+    { 5518.5f, 6.59543339f, 4.14115936f, 0.0136771758f },
+    { 5519.5f, 6.60003291f, 4.11136511f, 0.0159568059f },
+    { 5520.0f, 6.60368863f, 4.09705126f, 0.0170960438f },
+    { 5520.5f, 6.60575302f, 4.08121403f, 0.0182369945f },
+    { 5521.5f, 6.60637601f, 4.05197584f, 0.0205161911f },
+    { 5522.5f, 6.60593982f, 4.02196899f, 0.0227963281f },
+    { 5523.5f, 6.60185124f, 3.99283097f, 0.0250755299f },
+    { 5524.5f, 6.59583869f, 3.96303531f, 0.0273555319f },
+    { 5525.5f, 6.58683317f, 3.93387728f, 0.029634848f },
+    { 5526.5f, 6.57548143f, 3.90426143f, 0.0319147346f },
+    { 5527.5f, 6.56142774f, 3.87513367f, 0.034194114f },
+    { 5540.0f, 6.17281221f, 3.51078539f, 0.0626894058f },
+    { 5560.0f, 4.78741372f, 2.93351046f, 0.108281644f },
+    { 5580.0f, 2.66339273f, 2.34696617f, 0.153873927f },
+    { 5600.0f, 2.52679797f, 3.43769027f, 0.199466195f },
+    { 5620.0f, 2.39020322f, 4.52841438f, 0.245058463f },
+    { 5640.0f, 4.47289328f, 3.96658259f, 0.290650748f },
+    { 5660.0f, 5.7760345f, 3.44170508f, 0.336243015f },
+    { 5680.0f, 6.08108476f, 2.94255249f, 0.381835291f },
+    { 5700.0f, 5.35292215f, 2.48151282f, 0.427427572f },
+    { 5720.0f, 3.77181995f, 2.10971255f, 0.473019842f },
+    { 5740.0f, 1.890023f, 2.11319838f, 0.51861212f },
+    { 5760.0f, 1.96105332f, 3.03970405f, 0.564204395f },
+    { 5780.0f, 3.83736984f, 3.03438477f, 0.609796681f },
+    { 5800.0f, 5.37889961f, 2.71525243f, 0.655388944f },
+    { 5820.0f, 6.12389543f, 2.35167747f, 0.700981217f },
+    { 5840.0f, 5.99041552f, 2.01046849f, 0.746573493f },
+    { 5860.0f, 5.15370388f, 1.74545367f, 0.792165757f },
+    { 5880.0f, 4.0736068f, 1.64115759f, 0.837758041f },
+    { 5900.0f, 3.5145355f, 1.76090417f, 0.883350315f },
+    { 5920.0f, 3.93441505f, 1.88999798f, 0.928942591f },
+    { 5940.0f, 4.77151173f, 1.83740551f, 0.974534864f },
+    { 5960.0f, 5.42530903f, 1.68003376f, 1.02012714f },
+    { 5980.0f, 5.7231075f, 1.50282835f, 1.06571941f },
+    { 6000.0f, 5.76603064f, 1.34751508f, 1.11131169f },
+    { 6020.0f, 5.74448347f, 1.22059207f, 1.15690396f },
+    { 6040.0f, 5.75873185f, 1.10325863f, 1.20249624f },
+    { 6060.0f, 5.74736079f, 0.97882126f, 1.24808851f },
+    { 6080.0f, 5.60000716f, 0.855556202f, 1.2936808f },
+    { 6100.0f, 5.3245073f, 0.76252879f, 1.33927306f },
+    { 6120.0f, 5.11695349f, 0.722383673f, 1.38486533f },
+    { 6140.0f, 5.23039588f, 0.709051532f, 1.4304576f },
+    { 6160.0f, 5.68407327f, 0.655374901f, 1.47604988f },
+    { 6180.0f, 6.20723644f, 0.531113069f, 1.52164216f },
+    { 6200.0f, 6.49463992f, 0.357983975f, 1.56723443f },
+    { 6220.0f, 6.39896217f, 0.174654378f, 1.61282671f },
+    { 6240.0f, 5.97909768f, 0.019423443f, 1.65841898f },
+    { 6260.0f, 5.46434918f, 6.20363378f, 1.70401126f },
+    { 6280.0f, 5.12170694f, 6.15724057f, 1.74960353f },
+    { 6300.0f, 5.03978061f, 6.11924146f, 1.7951958f },
+    { 6320.0f, 5.06683971f, 6.05388319f, 1.84078807f },
+    { 6340.0f, 5.02852386f, 5.97158351f, 1.88638035f },
+    { 6360.0f, 4.9308879f, 5.90345503f, 1.93197263f },
+    { 6380.0f, 4.94536232f, 5.85596958f, 1.97756491f },
+    { 6400.0f, 5.18144475f, 5.78846389f, 2.02315717f },
+    { 6420.0f, 5.48268863f, 5.65736526f, 2.06874945f },
+    { 6440.0f, 5.52785273f, 5.46409685f, 2.11434172f },
+    { 6460.0f, 5.06466284f, 5.2472509f, 2.159934f },
+    { 6480.0f, 4.06966933f, 5.08155821f, 2.20552627f },
+    { 6500.0f, 2.93703013f, 5.13574736f, 2.25111855f },
+    { 6520.0f, 2.79454093f, 5.51727884f, 2.29671082f },
+    { 6540.0f, 3.98869454f, 5.64070937f, 2.3423031f },
+    { 6560.0f, 5.32192412f, 5.44622486f, 2.38789536f },
+    { 6580.0f, 6.05121684f, 5.12655451f, 2.43348764f },
+    { 6600.0f, 5.86791484f, 4.7628431f, 2.47907992f },
+    { 6620.0f, 4.73267277f, 4.40274689f, 2.5246722f },
+    { 6640.0f, 2.86295304f, 4.14305158f, 2.57026448f },
+    { 6660.0f, 1.1856934f, 4.70743247f, 2.61585674f },
+    { 6680.0f, 2.60114743f, 5.49730902f, 2.66144902f },
+    { 6700.0f, 4.55613873f, 5.2505617f, 2.70704129f },
+    { 6720.0f, 5.83158253f, 4.85629092f, 2.75263356f },
+    { 6740.0f, 6.14317297f, 4.42408429f, 2.79822584f },
+    { 6760.0f, 5.44472349f, 3.98175409f, 2.84381811f },
+    { 6780.0f, 3.88606964f, 3.550132f, 2.88941039f },
+    { 6800.0f, 1.78164679f, 3.2091697f, 2.93500266f },
+    { 6820.0f, 2.24551178f, 4.11513321f, 2.98059494f },
+    { 6840.0f, 2.70937676f, 5.02109673f, 3.02618721f },
+    { 6860.0f, 4.254468f, 4.60412319f, 3.07177948f },
+    { 6875.625f, 4.94739994f, 4.24915796f, 3.10739842f },
+    { 6876.625f, 4.97485914f, 4.22584851f, 3.10967826f },
+    { 6877.625f, 5.00017039f, 4.20295898f, 3.1119576f },
+    { 6878.625f, 5.02342563f, 4.17944653f, 3.11423761f },
+    { 6879.625f, 5.04465005f, 4.15664821f, 3.11651676f },
+    { 6880.0f, 5.05207709f, 4.1474138f, 3.11737221f },
+    { 6880.625f, 5.06366159f, 4.13282953f, 3.11879703f },
+    { 6881.625f, 5.08091378f, 4.11023138f, 3.12107589f },
+    { 6882.625f, 5.09561484f, 4.08594058f, 3.12335662f },
+    { 6883.625f, 5.10931503f, 4.06373199f, 3.12563495f },
+    { 6884.625f, 5.11918454f, 4.0385731f, 3.1279166f },
+    { 6885.625f, 5.1312204f, 4.01701441f, 3.13019404f },
+    { 6886.625f, 5.13463605f, 3.98985864f, 3.13247789f },
+    { 6887.625f, 5.15751292f, 3.96685946f, 3.13475602f },
+    { 6888.625f, 5.14209824f, 3.93359044f, 3.13704745f },
+    { 6889.625f, 5.13893291f, 4.34936122f, 3.13703778f },
+    { 6890.625f, 5.13576757f, 4.765132f, 3.13702811f },
+    { 6891.625f, 5.13260224f, 5.18090277f, 3.13701844f },
+    { 6892.625f, 5.1294369f, 5.59667355f, 3.13700877f },
+    { 6893.625f, 5.10500706f, 5.59943219f, 3.13475156f },
+    { 6894.625f, 5.11293927f, 5.62424586f, 3.1324693f },
+    { 6895.625f, 5.09848655f, 5.64295738f, 3.13019511f },
+    { 6896.625f, 5.08793736f, 5.66864209f, 3.12791302f },
+    { 6897.625f, 5.07173937f, 5.69020874f, 3.12563573f },
+    { 6898.625f, 5.05503028f, 5.71506166f, 3.12335476f },
+    { 6899.625f, 5.03553249f, 5.73769501f, 3.12107634f },
+    { 6900.0f, 5.02807335f, 5.74728868f, 3.12022069f },
+    { 6900.625f, 5.01443241f, 5.76210541f, 3.11879595f },
+    { 6901.625f, 4.99128146f, 5.78525549f, 3.11651702f },
+    { 6902.625f, 4.96623126f, 5.80944856f, 3.11423694f },
+    { 6903.625f, 4.93941886f, 5.83288428f, 3.11195773f },
+    { 6904.625f, 4.91062564f, 5.85696738f, 3.10967784f },
+    { 6905.625f, 4.88017457f, 5.88061406f, 3.10739846f },
+    { 6920.0f, 4.25480959f, 6.22694595f, 3.074629f },
+    { 6940.0f, 2.91711721f, 0.443802026f, 3.02903673f },
+    { 6960.0f, 1.27574454f, 1.03642633f, 2.98344445f },
+    { 6980.0f, 1.63286293f, 6.04844152f, 2.93785218f },
+    { 7000.0f, 1.98998133f, 4.77727141f, 2.8922599f },
+    { 7020.0f, 3.11462617f, 5.31197756f, 2.84666763f },
+    { 7040.0f, 3.74878239f, 5.82554643f, 2.80107535f },
+    { 7060.0f, 3.84982171f, 0.066810656f, 2.75548309f },
+    { 7080.0f, 3.4506578f, 0.62501519f, 2.70989081f },
+    { 7100.0f, 2.66033692f, 1.26124074f, 2.66429853f },
+    { 7120.0f, 1.71094487f, 2.11665204f, 2.61870629f },
+    { 7140.0f, 1.2576294f, 3.53779117f, 2.57311398f },
+    { 7160.0f, 1.92657085f, 4.83884545f, 2.52752171f },
+    { 7180.0f, 2.88473033f, 5.68221007f, 2.48192944f },
+    { 7200.0f, 3.65493487f, 0.115479259f, 2.43633716f },
+    { 7220.0f, 4.09593176f, 0.810917201f, 2.39074489f },
+    { 7240.0f, 4.17642807f, 1.52425991f, 2.34515261f },
+    { 7260.0f, 3.93498436f, 2.28164862f, 2.29956034f },
+    { 7280.0f, 3.47363666f, 3.11571895f, 2.25396806f },
+    { 7300.0f, 2.98517737f, 4.07519057f, 2.20837579f },
+    { 7320.0f, 2.79448367f, 5.18160689f, 2.16278352f },
+    { 7340.0f, 3.17723251f, 0.0184021798f, 2.11719124f },
+    { 7360.0f, 4.0012006f, 0.998275879f, 2.07159896f },
+    { 7380.0f, 4.91140298f, 1.84867797f, 2.02600669f },
+    { 7400.0f, 5.60214837f, 2.62610781f, 1.98041442f },
+    { 7420.0f, 5.85624357f, 3.37297296f, 1.93482214f },
+    { 7440.0f, 5.56140731f, 4.12510027f, 1.88922987f },
+    { 7460.0f, 4.75694137f, 4.93124844f, 1.8436376f },
+    { 7480.0f, 3.7355193f, 5.88491016f, 1.79804532f },
+    { 7500.0f, 3.22189244f, 0.803716645f, 1.75245304f },
+    { 7520.0f, 3.85922849f, 2.00403657f, 1.70686076f },
+    { 7540.0f, 5.07207674f, 2.95037259f, 1.6612685f },
+    { 7560.0f, 6.08443579f, 3.7433488f, 1.61567622f },
+    { 7580.0f, 6.50248513f, 4.47823243f, 1.57008394f },
+    { 7600.0f, 6.20073339f, 5.2085955f, 1.52449167f },
+    { 7620.0f, 5.27353332f, 5.98374276f, 1.4788994f },
+    { 7640.0f, 4.05511346f, 0.600683802f, 1.43330712f },
+    { 7660.0f, 3.20338921f, 1.73623064f, 1.38771485f },
+    { 7680.0f, 3.37746833f, 2.96505361f, 1.34212258f },
+    { 7700.0f, 4.17141295f, 3.97967661f, 1.2965303f },
+    { 7720.0f, 4.83174182f, 4.82958629f, 1.25093802f },
+    { 7740.0f, 5.03665784f, 5.62209356f, 1.20534575f },
+    { 7760.0f, 4.77453264f, 0.137289943f, 1.15975348f },
+    { 7780.0f, 4.21977991f, 0.985889576f, 1.1141612f },
+    { 7800.0f, 3.64088504f, 1.91384419f, 1.06856893f },
+    { 7820.0f, 3.25871061f, 2.90785752f, 1.02297665f },
+    { 7840.0f, 3.08450401f, 3.90916856f, 0.977384381f },
+    { 7860.0f, 2.96764144f, 4.88778613f, 0.931792106f },
+    { 7880.0f, 2.83030323f, 5.87187705f, 0.886199824f },
+    { 7900.0f, 2.76884285f, 0.605195759f, 0.840607558f },
+    { 7920.0f, 2.9150667f, 1.61123689f, 0.795015284f },
+    { 7940.0f, 3.206254f, 2.5317204f, 0.749423016f },
+    { 7960.0f, 3.40692862f, 3.35351064f, 0.703830737f },
+    { 7980.0f, 3.30021354f, 4.11195034f, 0.658238461f },
+    { 8000.0f, 2.79015094f, 4.85866976f, 0.612646186f },
+    { 8020.0f, 1.94321781f, 5.69257981f, 0.567053894f },
+    { 8040.0f, 1.15397524f, 0.675149811f, 0.521461634f },
+    { 8060.0f, 1.46558842f, 2.30509328f, 0.475869374f },
+    { 8080.0f, 2.41173953f, 3.25961857f, 0.430277096f },
+    { 8100.0f, 3.15482633f, 3.95481477f, 0.384684815f },
+    { 8120.0f, 3.42930119f, 4.5704014f, 0.33909254f },
+    { 8140.0f, 3.15091516f, 5.15634748f, 0.293500267f },
+    { 8160.0f, 2.35613885f, 5.74054593f, 0.247907993f },
+    { 8180.0f, 1.18641145f, 0.110271875f, 0.202315702f },
+    { 8200.0f, 1.36688326f, 5.15898385f, 0.156723437f },
+    { 8220.0f, 1.54735507f, 3.92451051f, 0.111131172f },
+    { 8240.0f, 2.57800935f, 4.51939587f, 0.0655388935f },
+    { 8253.75f, 3.03620593f, 4.8976318f, 0.0341941644f },
+    { 8254.75f, 3.06015629f, 4.924903f, 0.0319143815f },
+    { 8255.75f, 3.08263256f, 4.95181971f, 0.0296349668f },
+    { 8256.75f, 3.1039201f, 4.97918881f, 0.0273550105f },
+    { 8257.75f, 3.12363972f, 5.00586568f, 0.0250757796f },
+    { 8258.75f, 3.14220995f, 5.03349723f, 0.0227954818f },
+    { 8259.75f, 3.15922974f, 5.05980732f, 0.0205166264f },
+    { 8260.0f, 3.16317063f, 5.06739058f, 0.0199457841f },
+    { 8260.75f, 3.17500409f, 5.0880073f, 0.0182356341f },
+    { 8261.75f, 3.18950768f, 5.11365947f, 0.015957512f },
+    { 8262.75f, 3.20231914f, 5.14334184f, 0.0136748692f },
+    { 8263.75f, 3.21501875f, 5.16762512f, 0.0113984333f },
+    { 8264.75f, 3.22421667f, 5.20265193f, 0.0091100444f },
+    { 8265.75f, 3.24155433f, 5.2252459f, 0.00683710236f },
+    { 8266.75f, 3.24426115f, 4.99867944f, 0.00637740093f },
+    { 8267.75f, 3.24696796f, 4.77211298f, 0.0059176995f },
+    { 8268.75f, 3.24967477f, 4.54554651f, 0.00545799808f },
+    { 8269.75f, 3.25238159f, 4.31898005f, 0.00499829665f },
+    { 8270.75f, 3.2550884f, 4.09241359f, 0.00453859523f },
+    { 8271.75f, 3.24217814f, 4.04092863f, 0.00684122025f },
+    { 8272.75f, 3.2530302f, 4.01650866f, 0.00911850273f },
+    { 8273.75f, 3.24784937f, 3.9900585f, 0.0113974768f },
+    { 8274.75f, 3.24612316f, 3.96222885f, 0.0136783602f },
+    { 8275.75f, 3.23981267f, 3.93647475f, 0.015956834f },
+    { 8276.75f, 3.23359074f, 3.90886643f, 0.0182374468f },
+    { 8277.75f, 3.2249603f, 3.88287942f, 0.020516229f },
+    { 8278.75f, 3.21543231f, 3.85556239f, 0.0227965224f },
+    { 8279.75f, 3.20416243f, 3.82933049f, 0.0250755842f },
+    { 8280.0f, 3.2011844f, 3.8222214f, 0.0256459577f },
+    { 8280.75f, 3.1916639f, 3.80224534f, 0.0273556149f },
+    { 8281.75f, 3.17769177f, 3.77583583f, 0.0296348773f },
+    { 8282.75f, 3.16233134f, 3.74885276f, 0.0319147834f },
+    { 8283.75f, 3.14561813f, 3.72235794f, 0.0341941474f },
+    { 8300.0f, 2.68893937f, 3.28605352f, 0.0712379286f },
+    { 8320.0f, 1.718515f, 2.73256582f, 0.116830186f },
+    { 8340.0f, 1.82769377f, 3.28945899f, 0.162422463f },
+    { 8360.0f, 1.93687254f, 3.84635216f, 0.208014739f },
+    { 8380.0f, 2.04605131f, 4.40324533f, 0.253607015f },
+    { 8400.0f, 2.84857206f, 3.83112039f, 0.2991993f },
+    { 8420.0f, 3.15567394f, 3.25031684f, 0.344791584f },
+    { 8440.0f, 2.92974445f, 2.63684077f, 0.390383845f },
+    { 8460.0f, 2.24837328f, 1.94234222f, 0.435976123f },
+    { 8480.0f, 1.36196407f, 0.98575415f, 0.481568404f },
+    { 8500.0f, 1.07268307f, 5.61827506f, 0.527160672f },
+    { 8520.0f, 1.8344774f, 4.34635976f, 0.572752949f },
+    { 8540.0f, 2.65343291f, 3.50777038f, 0.618345221f },
+    { 8560.0f, 3.1651453f, 2.75288191f, 0.663937492f },
+    { 8580.0f, 3.31364419f, 1.98477111f, 0.709529769f },
+    { 8600.0f, 3.19209143f, 1.1569042f, 0.755122044f },
+    { 8620.0f, 2.99333618f, 0.244860776f, 0.800714322f },
+    { 8640.0f, 2.90514705f, 5.55097557f, 0.846306592f },
+    { 8660.0f, 2.96572431f, 4.5660307f, 0.891898887f },
+    { 8680.0f, 3.07428063f, 3.60037903f, 0.937491141f },
+    { 8700.0f, 3.16766653f, 2.63259211f, 0.983083415f },
+    { 8720.0f, 3.32073819f, 1.6432741f, 1.02867568f },
+    { 8740.0f, 3.65880729f, 0.659861712f, 1.07426796f },
+    { 8760.0f, 4.17080126f, 6.01613563f, 1.11986024f },
+    { 8780.0f, 4.67182185f, 5.15970805f, 1.16545251f },
+    { 8800.0f, 4.93622286f, 4.3502776f, 1.21104479f },
+    { 8820.0f, 4.81868391f, 3.55057857f, 1.25663706f },
+    { 8840.0f, 4.32231068f, 2.71283861f, 1.30222934f },
+    { 8860.0f, 3.65518374f, 1.77014196f, 1.34782161f },
+    { 8880.0f, 3.26430135f, 0.672494221f, 1.39341388f },
+    { 8900.0f, 3.53943931f, 5.82765566f, 1.43900616f },
+    { 8920.0f, 4.25923868f, 4.84562886f, 1.48459843f },
+    { 8940.0f, 4.9380008f, 3.99375289f, 1.53019071f },
+    { 8960.0f, 5.27633725f, 3.20405907f, 1.57578298f },
+    { 8980.0f, 5.17580373f, 2.42899184f, 1.62137525f },
+    { 9000.0f, 4.68424817f, 1.63318276f, 1.66696753f },
+    { 9020.0f, 3.95496791f, 0.779923608f, 1.7125598f },
+    { 9040.0f, 3.21824962f, 6.10722429f, 1.75815208f },
+    { 9060.0f, 2.75270524f, 5.02178079f, 1.80374435f },
+    { 9080.0f, 2.74999346f, 3.8879298f, 1.84933664f },
+    { 9100.0f, 3.11205201f, 2.84823347f, 1.8949289f },
+    { 9120.0f, 3.57895708f, 1.93512843f, 1.94052118f },
+    { 9140.0f, 3.93619495f, 1.11568153f, 1.98611345f },
+    { 9160.0f, 4.03472793f, 0.358196679f, 2.03170573f },
+    { 9180.0f, 3.77769843f, 5.92202604f, 2.077298f },
+    { 9200.0f, 3.133193f, 5.21438921f, 2.12289027f },
+    { 9220.0f, 2.16003304f, 4.4610402f, 2.16848254f },
+    { 9240.0f, 1.10107555f, 3.39599017f, 2.21407482f },
+    { 9260.0f, 1.05572531f, 1.46631258f, 2.2596671f },
+    { 9280.0f, 2.04866228f, 0.414287709f, 2.30525938f },
+    { 9300.0f, 2.91045155f, 6.02836752f, 2.35085165f },
+    { 9320.0f, 3.3648347f, 5.45995283f, 2.39644391f },
+    { 9340.0f, 3.32908646f, 4.93996878f, 2.4420362f },
+    { 9360.0f, 2.81885778f, 4.45589603f, 2.48762847f },
+    { 9380.0f, 1.92610799f, 4.01463053f, 2.53322074f },
+    { 9400.0f, 1.81744892f, 4.52906819f, 2.57881301f },
+    { 9420.0f, 1.70878986f, 5.04350585f, 2.62440529f },
+    { 9440.0f, 1.6001308f, 5.55794351f, 2.66999756f },
+    { 9460.0f, 2.49846699f, 5.17197022f, 2.71558985f },
+    { 9480.0f, 3.04300015f, 4.75567257f, 2.76118211f },
+    { 9500.0f, 3.14361872f, 4.32709087f, 2.80677439f },
+    { 9520.0f, 2.76156364f, 3.88828024f, 2.85236666f },
+    { 9540.0f, 1.92367622f, 3.43609788f, 2.89795894f },
+    { 9560.0f, 1.93285249f, 4.03913034f, 2.94355121f },
+    { 9580.0f, 1.94202875f, 4.6421628f, 2.98914349f },
+    { 9600.0f, 1.95120502f, 5.24519526f, 3.03473576f },
+    { 9620.0f, 2.96434062f, 4.75731147f, 3.08032808f },
+    { 9631.875f, 3.33404216f, 4.46587806f, 3.10739847f },
+    { 9632.875f, 3.35584897f, 4.44103573f, 3.10967827f },
+    { 9633.875f, 3.37596173f, 4.4164838f, 3.1119577f },
+    { 9634.875f, 3.39468471f, 4.39146865f, 3.11423764f },
+    { 9635.875f, 3.41163212f, 4.36703779f, 3.11651687f },
+    { 9636.875f, 3.42720523f, 4.34163124f, 3.11879716f },
+    { 9637.875f, 3.44109833f, 4.31749097f, 3.121076f },
+    { 9638.875f, 3.45346964f, 4.29140816f, 3.12335696f },
+    { 9639.875f, 3.46442648f, 4.26780092f, 3.12563509f },
+    { 9640.0f, 3.46510069f, 4.26445898f, 3.12592031f },
+    { 9640.875f, 3.4732875f, 4.24020775f, 3.12791763f },
+    { 9641.875f, 3.48218991f, 4.21778609f, 3.13019416f },
+    { 9642.875f, 3.48680684f, 4.18520771f, 3.13248197f },
+    { 9643.875f, 3.5009295f, 4.16387119f, 3.13475566f },
+    { 9644.875f, 3.4980732f, 4.40425303f, 3.13521418f },
+    { 9645.875f, 3.49521691f, 4.64463488f, 3.1356727f },
+    { 9646.875f, 3.49236061f, 4.88501672f, 3.13613122f },
+    { 9647.875f, 3.48950431f, 5.12539856f, 3.13658974f },
+    { 9648.875f, 3.48664801f, 5.36578041f, 3.13704827f },
+    { 9649.875f, 3.46708284f, 5.40994674f, 3.13475143f },
+    { 9650.875f, 3.47253071f, 5.43333016f, 3.13247355f },
+    { 9651.875f, 3.460721f, 5.45780733f, 3.13019516f },
+    { 9652.875f, 3.45237392f, 5.48438747f, 3.12791414f },
+    { 9653.875f, 3.43906039f, 5.50870632f, 3.12563581f },
+    { 9654.875f, 3.42563178f, 5.53511303f, 3.12335515f },
+    { 9655.875f, 3.40946256f, 5.5598662f, 3.12107642f },
+    { 9656.875f, 3.3921894f, 5.5860417f, 3.11879614f },
+    { 9657.875f, 3.37290544f, 5.61117512f, 3.11651709f },
+    { 9658.875f, 3.35214147f, 5.63728075f, 3.11423702f },
+    { 9659.875f, 3.32962249f, 5.66271901f, 3.11195777f },
+    { 9660.0f, 3.32669237f, 5.66605779f, 3.11167271f },
+    { 9660.875f, 3.30547475f, 5.68880998f, 3.10967788f },
+    { 9661.875f, 3.27972419f, 5.714502f, 3.1073985f },
+    { 9680.0f, 2.54623783f, 6.20197464f, 3.06608043f },
+    { 9700.0f, 1.27157417f, 0.581072638f, 3.02048817f },
+    { 9720.0f, 1.61321273f, 5.53182386f, 2.97489591f },
+    { 9740.0f, 1.95485128f, 4.19938977f, 2.92930364f },
+    { 9760.0f, 3.10864628f, 4.78518839f, 2.88371136f },
+    { 9780.0f, 3.64660832f, 5.31922156f, 2.83811908f },
+    { 9800.0f, 3.42800117f, 5.83967154f, 2.7925268f },
+    { 9820.0f, 2.47792588f, 0.0741790047f, 2.74693454f },
+    { 9840.0f, 2.42646875f, 5.80140468f, 2.70134227f },
+    { 9860.0f, 2.37501162f, 5.24544505f, 2.65575f },
+    { 9880.0f, 2.32355449f, 4.68948541f, 2.61015772f },
+    { 9900.0f, 3.41610488f, 5.18947809f, 2.56456543f },
+    { 9920.0f, 3.77111428f, 5.67120886f, 2.51897313f },
+    { 9940.0f, 3.30388168f, 6.11934832f, 2.47338088f },
+    { 9960.0f, 2.1365538f, 0.176674731f, 2.4277886f },
+    { 9980.0f, 1.9822381f, 5.82552981f, 2.38219633f },
+    { 10000.0f, 1.8279224f, 5.19119959f, 2.33660406f },
+    { 10020.0f, 3.30652275f, 5.44799947f, 2.29101179f },
+    { 10040.0f, 4.23736537f, 5.85353175f, 2.24541951f },
+    { 10060.0f, 4.35492825f, 6.27576144f, 2.19982724f },
+    { 10080.0f, 3.63128467f, 0.372317991f, 2.15423496f },
+    { 10100.0f, 2.32478228f, 0.564295228f, 2.10864269f },
+    { 10120.0f, 1.5466482f, 0.034185115f, 2.06305037f },
+    { 10140.0f, 2.7619543f, 5.9749337f, 2.01745814f },
+    { 10160.0f, 4.28954227f, 6.23071147f, 1.97186587f },
+    { 10180.0f, 5.25498961f, 0.340481928f, 1.92627359f },
+    { 10200.0f, 5.38259784f, 0.761845712f, 1.88068132f },
+    { 10220.0f, 4.64702453f, 1.1608219f, 1.83508904f },
+    { 10240.0f, 3.26783847f, 1.45041252f, 1.78949676f },
+    { 10260.0f, 1.93698371f, 1.31477895f, 1.74390449f },
+    { 10280.0f, 2.3177762f, 0.767031994f, 1.69831222f },
+    { 10300.0f, 3.75409679f, 0.855081107f, 1.65271994f },
+    { 10320.0f, 4.87255641f, 1.19940799f, 1.60712767f },
+    { 10340.0f, 5.27851949f, 1.60535738f, 1.56153539f },
+    { 10360.0f, 4.90526578f, 2.00766652f, 1.51594312f },
+    { 10380.0f, 3.90653837f, 2.34597431f, 1.47035085f },
+    { 10400.0f, 2.69565746f, 2.48792164f, 1.42475857f },
+    { 10420.0f, 2.14491622f, 2.24728057f, 1.37916628f },
+    { 10440.0f, 2.76035907f, 2.10370769f, 1.33357402f },
+    { 10460.0f, 3.57375276f, 2.30911721f, 1.28798173f },
+    { 10480.0f, 3.94127424f, 2.64703705f, 1.24238947f },
+    { 10500.0f, 3.70643605f, 3.00184479f, 1.1967972f },
+    { 10520.0f, 2.98286029f, 3.28370446f, 1.15120495f },
+    { 10540.0f, 2.17627206f, 3.33849394f, 1.10561266f },
+    { 10560.0f, 2.04100114f, 3.11604575f, 1.06002038f },
+    { 10580.0f, 2.65936872f, 3.10974742f, 1.01442811f },
+    { 10600.0f, 3.24630266f, 3.37399534f, 0.96883583f },
+    { 10620.0f, 3.3561854f, 3.74258028f, 0.923243555f },
+    { 10640.0f, 2.87276577f, 4.12316455f, 0.877651281f },
+    { 10660.0f, 1.90902979f, 4.4003726f, 0.832058995f },
+    { 10680.0f, 1.01003403f, 4.08526332f, 0.786466731f },
+    { 10700.0f, 1.58144387f, 3.45557944f, 0.740874458f },
+    { 10720.0f, 2.63863586f, 3.66169572f, 0.695282172f },
+    { 10740.0f, 3.29238873f, 4.06889113f, 0.649689908f },
+    { 10760.0f, 3.30825184f, 4.5255104f, 0.60409764f },
+    { 10780.0f, 2.65676767f, 4.98174075f, 0.558505361f },
+    { 10800.0f, 1.48050386f, 5.3500488f, 0.512913086f },
+    { 10820.0f, 1.56260244f, 4.58751478f, 0.467320814f },
+    { 10840.0f, 1.64470102f, 3.82498077f, 0.421728541f },
+    { 10860.0f, 2.7649943f, 4.23036887f, 0.376136264f },
+    { 10880.0f, 3.31099342f, 4.71675036f, 0.330543973f },
+    { 10900.0f, 3.140551f, 5.22187554f, 0.284951715f },
+    { 10920.0f, 2.27580564f, 5.72315418f, 0.239359441f },
+    { 10940.0f, 2.26985271f, 5.25502172f, 0.193767165f },
+    { 10960.0f, 2.26389977f, 4.78688927f, 0.14817489f },
+    { 10980.0f, 2.25794683f, 4.31875682f, 0.102582615f },
+    { 11000.0f, 3.33336294f, 4.83144583f, 0.0569903095f },
+    { 11010.0f, 3.6296678f, 5.09585189f, 0.0341942156f },
+    { 11011.0f, 3.64924075f, 5.12268674f, 0.0319143697f },
+    { 11012.0f, 3.66686389f, 5.14906827f, 0.029635032f },
+    { 11013.0f, 3.68263746f, 5.1760909f, 0.0273550305f },
+    { 11014.0f, 3.69644877f, 5.20241082f, 0.0250758576f },
+    { 11015.0f, 3.70838039f, 5.22976195f, 0.022795554f },
+    { 11016.0f, 3.71845739f, 5.25580592f, 0.0205167406f },
+    { 11017.0f, 3.72637343f, 5.28367108f, 0.0182359192f },
+    { 11018.0f, 3.73305216f, 5.3093127f, 0.0159576597f },
+    { 11019.0f, 3.73665636f, 5.33816911f, 0.0136757776f },
+    { 11020.0f, 3.74108536f, 5.36299772f, 0.0113986075f },
+    { 11021.0f, 3.73915537f, 5.39450162f, 0.00911384933f },
+    { 11022.0f, 3.75040081f, 5.42029896f, 0.0068366559f },
+    { 11023.0f, 3.73431626f, 5.46417287f, 0.00453789854f },
+    { 11024.0f, 5.14665625f, 1.57079609f, 2.27178495e-10f },
+    { 11025.0f, 5.26021762f, 4.71238893f, 5.36295678e-11f },
+};
+
+static const TPqfWidebandPoint PqfWidebandTable1[] = {
+    { 1.0f, 16.3763317f, 0.321157098f, 0.00166186523f },
+    { 2.0f, 15.6547709f, 6.13654044f, 0.00465621712f },
+    { 3.0f, 15.6606253f, 6.20915897f, 0.00683819362f },
+    { 4.0f, 15.6134856f, 6.17706018f, 0.00912945106f },
+    { 5.0f, 15.5885084f, 6.16376938f, 0.0113983377f },
+    { 6.0f, 15.5394571f, 6.13807464f, 0.013680542f },
+    { 7.0f, 15.4940257f, 6.11688701f, 0.0159575958f },
+    { 8.0f, 15.433528f, 6.09268841f, 0.0182379188f },
+    { 9.0f, 15.3710316f, 6.06980385f, 0.0205167747f },
+    { 10.0f, 15.2970519f, 6.0460895f, 0.022796539f },
+    { 11.0f, 15.2186392f, 6.02270898f, 0.0250759551f },
+    { 12.0f, 15.1305359f, 5.99919959f, 0.027355526f },
+    { 13.0f, 15.0367893f, 5.97567334f, 0.0296351432f },
+    { 14.0f, 14.9344304f, 5.95226965f, 0.0319146489f },
+    { 15.0f, 14.8257622f, 5.92873888f, 0.0341943338f },
+    { 20.0f, 14.1731457f, 5.81208672f, 0.0455922597f },
+    { 40.0f, 9.96279371f, 5.36584838f, 0.0911845499f },
+    { 60.0f, 3.98493164f, 5.09463212f, 0.136776822f },
+    { 80.0f, 3.41335407f, 0.66970459f, 0.18236911f },
+    { 100.0f, 9.40059243f, 0.456773194f, 0.227961372f },
+    { 120.0f, 13.7055892f, 0.0210326918f, 0.273553646f },
+    { 140.0f, 15.3515353f, 5.84449986f, 0.31914592f },
+    { 160.0f, 14.0286338f, 5.39289849f, 0.364738195f },
+    { 180.0f, 10.0636806f, 4.98914606f, 0.410330469f },
+    { 200.0f, 4.58324604f, 4.8518744f, 0.455922743f },
+    { 220.0f, 3.90829898f, 6.16411514f, 0.501515003f },
+    { 240.0f, 9.28116408f, 6.13667506f, 0.547107292f },
+    { 260.0f, 13.319209f, 5.75938686f, 0.592699567f },
+    { 280.0f, 14.7655206f, 5.33713342f, 0.638291841f },
+    { 300.0f, 13.3053404f, 4.92909239f, 0.683884115f },
+    { 320.0f, 9.37616456f, 4.61155487f, 0.729476393f },
+    { 340.0f, 4.799274f, 4.74897351f, 0.775068666f },
+    { 360.0f, 6.07215931f, 5.57969947f, 0.820660938f },
+    { 380.0f, 11.0245011f, 5.49262185f, 0.866253214f },
+    { 400.0f, 14.5056712f, 5.14569185f, 0.911845487f },
+    { 420.0f, 15.1602187f, 4.75442338f, 0.957437761f },
+    { 440.0f, 12.6829302f, 4.39642141f, 1.00303003f },
+    { 460.0f, 7.87154706f, 4.24073859f, 1.04862232f },
+    { 480.0f, 5.4827112f, 4.94305749f, 1.09421458f },
+    { 500.0f, 11.130787f, 5.23738534f, 1.13980686f },
+    { 520.0f, 17.5227042f, 4.95607885f, 1.18539913f },
+    { 540.0f, 21.4503255f, 4.55885084f, 1.23099141f },
+    { 560.0f, 21.5420634f, 4.13729414f, 1.27658368f },
+    { 580.0f, 17.3314555f, 3.74046461f, 1.32217596f },
+    { 600.0f, 9.52980043f, 3.51921741f, 1.36776823f },
+    { 620.0f, 5.68561869f, 4.6513422f, 1.41336051f },
+    { 640.0f, 16.0134667f, 4.87266182f, 1.45895277f },
+    { 660.0f, 26.5914116f, 4.51692358f, 1.50454505f },
+    { 680.0f, 33.7228575f, 4.08237903f, 1.55013733f },
+    { 700.0f, 35.4178569f, 3.62976602f, 1.5957296f },
+    { 720.0f, 30.6473936f, 3.18428483f, 1.64132188f },
+    { 740.0f, 19.6227099f, 2.79702938f, 1.68691415f },
+    { 760.0f, 5.52145252f, 3.12089296f, 1.73250641f },
+    { 780.0f, 16.7761902f, 4.43509876f, 1.7780987f },
+    { 800.0f, 34.329543f, 4.10102989f, 1.82369097f },
+    { 820.0f, 47.4905951f, 3.65944822f, 1.86928325f },
+    { 840.0f, 52.5674056f, 3.197229f, 1.91487552f },
+    { 860.0f, 47.0457467f, 2.73718413f, 1.9604678f },
+    { 880.0f, 30.2129762f, 2.31710311f, 2.00606007f },
+    { 900.0f, 5.84825716f, 2.71221446f, 2.05165235f },
+    { 920.0f, 29.9144838f, 4.14585804f, 2.09724462f },
+    { 940.0f, 60.1720119f, 3.74282368f, 2.14283689f },
+    { 960.0f, 78.1100358f, 3.27495317f, 2.18842917f },
+    { 980.0f, 70.088855f, 2.79039234f, 2.23402144f },
+    { 1000.0f, 20.0011175f, 2.28653225f, 2.27961372f },
+    { 1020.0f, 90.2722411f, 4.95816514f, 2.32520599f },
+    { 1040.0f, 280.145467f, 4.45966162f, 2.37079827f },
+    { 1060.0f, 569.565693f, 3.96177321f, 2.41639054f },
+    { 1080.0f, 978.101405f, 3.46305683f, 2.46198281f },
+    { 1100.0f, 1523.99373f, 2.96345153f, 2.50757509f },
+    { 1120.0f, 2223.15273f, 2.46303466f, 2.55316736f },
+    { 1140.0f, 3088.12696f, 1.9619066f, 2.59875964f },
+    { 1160.0f, 4127.08095f, 1.46017152f, 2.64435191f },
+    { 1180.0f, 5342.83395f, 0.957935734f, 2.68994419f },
+    { 1200.0f, 6732.03243f, 0.455303947f, 2.73553646f },
+    { 1220.0f, 8284.54656f, 6.23556321f, 2.78112873f },
+    { 1240.0f, 9983.19055f, 5.7324371f, 2.82672101f },
+    { 1260.0f, 11803.8527f, 5.22919717f, 2.87231328f },
+    { 1280.0f, 13716.1129f, 4.72591529f, 2.91790556f },
+    { 1300.0f, 15684.3517f, 4.2226514f, 2.96349783f },
+    { 1320.0f, 17669.3695f, 3.71945067f, 3.0090901f },
+    { 1340.0f, 19630.3149f, 3.21633598f, 3.05468238f },
+    { 1360.0f, 21526.9695f, 2.71341426f, 3.10027456f },
+    { 1363.125f, 21814.964f, 2.63470782f, 3.10739849f },
+    { 1364.125f, 21906.3297f, 2.60977783f, 3.10967786f },
+    { 1365.125f, 21997.7234f, 2.58437871f, 3.11195776f },
+    { 1366.125f, 22088.6744f, 2.5595807f, 3.11423699f },
+    { 1367.125f, 22179.0909f, 2.53403081f, 3.11651706f },
+    { 1368.125f, 22269.8682f, 2.50944113f, 3.11879605f },
+    { 1369.125f, 22358.6179f, 2.48365257f, 3.12107639f },
+    { 1370.125f, 22449.8701f, 2.45940651f, 3.123355f },
+    { 1371.125f, 22534.9176f, 2.43323446f, 3.12563579f },
+    { 1372.125f, 22628.6439f, 2.40957833f, 3.12791372f },
+    { 1373.125f, 22701.9152f, 2.38288837f, 3.13019516f },
+    { 1374.125f, 22806.2307f, 2.36009989f, 3.13247199f },
+    { 1375.125f, 22810.3097f, 2.33575942f, 3.13475143f },
+    { 1376.125f, 22984.0957f, 2.30592031f, 3.13703405f },
+    { 1377.125f, 23074.7896f, 1.95292231f, 3.13704419f },
+    { 1378.125f, 23165.4835f, 1.59992431f, 3.13705432f },
+    { 1379.125f, 23256.1775f, 1.24692631f, 3.13706445f },
+    { 1380.0f, 23335.5347f, 0.938053059f, 3.13707332f },
+    { 1380.125f, 23346.8714f, 0.893928309f, 3.13707459f },
+    { 1381.125f, 23497.2363f, 0.955680793f, 3.13475582f },
+    { 1382.125f, 23509.3765f, 0.978205f, 3.13248072f },
+    { 1383.125f, 23605.5254f, 1.00976244f, 3.13019412f },
+    { 1384.125f, 23678.8572f, 1.03258496f, 3.12791733f },
+    { 1385.125f, 23766.0047f, 1.06017104f, 3.12563504f },
+    { 1386.125f, 23847.9217f, 1.08408018f, 3.12335688f },
+    { 1387.125f, 23932.3485f, 1.11040215f, 3.12107597f },
+    { 1388.125f, 24015.8726f, 1.13486847f, 3.11879713f },
+    { 1389.125f, 24099.0247f, 1.16064042f, 3.11651683f },
+    { 1390.125f, 24182.5087f, 1.18540432f, 3.11423765f },
+    { 1391.125f, 24264.8099f, 1.2108953f, 3.11195765f },
+    { 1392.125f, 24347.7392f, 1.23582785f, 3.10967828f },
+    { 1393.125f, 24429.3233f, 1.26116154f, 3.10739846f },
+    { 1400.0f, 24983.7006f, 1.4340275f, 3.0917261f },
+    { 1420.0f, 26485.8448f, 1.93681133f, 3.04613384f },
+    { 1440.0f, 27811.5187f, 2.43957655f, 3.00054155f },
+    { 1460.0f, 28951.8745f, 2.94233734f, 2.95494928f },
+    { 1480.0f, 29906.7403f, 3.44513335f, 2.90935701f },
+    { 1500.0f, 30683.6674f, 3.94798722f, 2.86376473f },
+    { 1520.0f, 31296.6796f, 4.45091248f, 2.81817246f },
+    { 1540.0f, 31764.5321f, 4.95391083f, 2.77258018f },
+    { 1560.0f, 32108.8503f, 5.45697015f, 2.72698791f },
+    { 1580.0f, 32352.2536f, 5.96006765f, 2.68139563f },
+    { 1600.0f, 32516.7081f, 0.179988557f, 2.63580336f },
+    { 1620.0f, 32622.2089f, 0.683072408f, 2.59021109f },
+    { 1640.0f, 32685.896f, 1.18610486f, 2.54461881f },
+    { 1660.0f, 32721.6117f, 1.68906855f, 2.49902654f },
+    { 1680.0f, 32739.8575f, 2.191958f, 2.45343426f },
+    { 1700.0f, 32748.0747f, 2.69478296f, 2.40784199f },
+    { 1720.0f, 32751.1355f, 3.19756608f, 2.36224971f },
+    { 1740.0f, 32751.9342f, 3.70033829f, 2.31665744f },
+    { 1760.0f, 32751.9786f, 4.20313308f, 2.27106517f },
+    { 1780.0f, 32751.9101f, 4.70597946f, 2.22547289f },
+    { 1800.0f, 32751.9054f, 5.20889616f, 2.17988062f },
+    { 1820.0f, 32751.9489f, 5.71188836f, 2.13428834f },
+    { 1840.0f, 32751.9876f, 6.2149462f, 2.08869607f },
+    { 1860.0f, 32751.9944f, 0.43486113f, 2.04310379f },
+    { 1880.0f, 32751.9756f, 0.937973228f, 1.99751152f },
+    { 1900.0f, 32751.9533f, 1.44106389f, 1.95191925f },
+    { 1920.0f, 32751.9464f, 1.94410482f, 1.90632697f },
+    { 1940.0f, 32751.9577f, 2.4470772f, 1.8607347f },
+    { 1960.0f, 32751.9786f, 2.94997504f, 1.81514242f },
+    { 1980.0f, 32751.9938f, 3.45280734f, 1.76955015f },
+    { 2000.0f, 32751.9953f, 3.95559434f, 1.72395787f },
+    { 2020.0f, 32751.9832f, 4.45836428f, 1.6783656f },
+    { 2040.0f, 32751.9664f, 4.96114782f, 1.63277332f },
+    { 2060.0f, 32751.956f, 5.46397106f, 1.58718105f },
+    { 2080.0f, 32751.9587f, 5.96685273f, 1.54158878f },
+    { 2100.0f, 32751.9726f, 0.186614097f, 1.4959965f },
+    { 2120.0f, 32751.9892f, 0.689621375f, 1.45040423f },
+    { 2140.0f, 32751.9968f, 1.19267392f, 1.40481195f },
+    { 2160.0f, 32751.9894f, 1.69575029f, 1.35921968f },
+    { 2180.0f, 32751.9701f, 2.19882603f, 1.3136274f },
+    { 2200.0f, 32751.9511f, 2.70188f, 1.26803513f },
+    { 2220.0f, 32751.9453f, 3.20489671f, 1.22244286f },
+    { 2240.0f, 32751.9591f, 3.70786803f, 1.17685058f },
+    { 2260.0f, 32751.9832f, 4.21079488f, 1.13125831f },
+    { 2280.0f, 32751.9965f, 4.71368483f, 1.08566603f },
+    { 2300.0f, 32751.9788f, 5.21655048f, 1.04007376f },
+    { 2320.0f, 32751.9332f, 5.7194059f, 0.994481484f },
+    { 2340.0f, 32751.8971f, 6.22226377f, 0.94888921f },
+    { 2360.0f, 32751.9233f, 0.44194982f, 0.903296935f },
+    { 2380.0f, 32751.9932f, 0.944840098f, 0.857704661f },
+    { 2400.0f, 32751.8311f, 1.4477522f, 0.812112387f },
+    { 2420.0f, 32750.598f, 1.95068508f, 0.766520112f },
+    { 2440.0f, 32746.4526f, 2.45363509f, 0.720927838f },
+    { 2460.0f, 32736.0067f, 2.95659922f, 0.675335564f },
+    { 2480.0f, 32713.7235f, 3.45957347f, 0.629743289f },
+    { 2500.0f, 32671.3438f, 3.96255477f, 0.584151015f },
+    { 2520.0f, 32597.443f, 4.46553982f, 0.538558741f },
+    { 2540.0f, 32477.2299f, 4.96852575f, 0.492966466f },
+    { 2560.0f, 32292.6978f, 5.47150911f, 0.447374192f },
+    { 2580.0f, 32023.187f, 5.97448561f, 0.401781917f },
+    { 2600.0f, 31646.4007f, 0.194265136f, 0.356189643f },
+    { 2620.0f, 31139.8174f, 0.697214625f, 0.310597369f },
+    { 2640.0f, 30482.4304f, 1.20014426f, 0.265005095f },
+    { 2660.0f, 29656.6267f, 1.70305381f, 0.219412819f },
+    { 2680.0f, 28650.0476f, 2.20594139f, 0.173820547f },
+    { 2700.0f, 27457.2031f, 2.70881545f, 0.128228271f },
+    { 2720.0f, 26080.5954f, 3.21166788f, 0.08263601f },
+    { 2740.0f, 24531.5011f, 3.71454152f, 0.037043722f },
+    { 2741.25f, 24429.0908f, 3.74602642f, 0.0341941413f },
+    { 2742.25f, 24346.7948f, 3.77095237f, 0.0319147713f },
+    { 2743.25f, 24264.1202f, 3.79635528f, 0.0296348653f },
+    { 2744.25f, 24181.3137f, 3.82117018f, 0.027355621f },
+    { 2745.25f, 24097.3329f, 3.84670658f, 0.0250755642f },
+    { 2746.25f, 24014.3536f, 3.87136256f, 0.0227965016f },
+    { 2747.25f, 23928.3108f, 3.89709432f, 0.0205162233f },
+    { 2748.25f, 23845.962f, 3.92153171f, 0.0182374171f },
+    { 2749.25f, 23755.667f, 3.94753797f, 0.015956825f },
+    { 2750.25f, 23676.2472f, 3.97176018f, 0.0136783048f },
+    { 2751.25f, 23573.2668f, 3.9979661f, 0.0113974676f },
+    { 2752.25f, 23505.6567f, 4.02293911f, 0.00911836787f },
+    { 2753.25f, 23332.1057f, 4.04565947f, 0.00684122267f },
+    { 2754.25f, 23339.6111f, 4.09619216f, 0.00453792451f },
+    { 2755.25f, 23264.2191f, 4.323028f, 0.0049977536f },
+    { 2756.25f, 23188.8272f, 4.54986385f, 0.00545758269f },
+    { 2757.25f, 23113.4352f, 4.7766997f, 0.00591741178f },
+    { 2758.25f, 23038.0432f, 5.00353555f, 0.00637724087f },
+    { 2759.25f, 22962.6512f, 5.23037139f, 0.00683706996f },
+    { 2760.0f, 22869.2891f, 5.21324465f, 0.00854342661f },
+    { 2760.25f, 22812.1206f, 5.20934991f, 0.0091101443f },
+    { 2761.25f, 22729.9562f, 5.17611051f, 0.0113984521f },
+    { 2762.25f, 22632.0127f, 5.15354688f, 0.0136748975f },
+    { 2763.25f, 22543.2982f, 5.12561799f, 0.0159575323f },
+    { 2764.25f, 22452.1237f, 5.10174071f, 0.0182356486f },
+    { 2765.25f, 22361.6076f, 5.07534309f, 0.0205166269f },
+    { 2766.25f, 22271.478f, 5.05085176f, 0.0227954785f },
+    { 2767.25f, 22180.1822f, 5.02507625f, 0.0250757791f },
+    { 2768.25f, 22089.8601f, 5.0002747f, 0.0273549941f },
+    { 2769.25f, 21998.0595f, 4.97480019f, 0.0296349656f },
+    { 2770.25f, 21907.2139f, 4.94982986f, 0.0319143759f },
+    { 2771.25f, 21814.9884f, 4.92451595f, 0.0341941714f },
+    { 2780.0f, 21002.2385f, 4.70445754f, 0.0541408034f },
+    { 2800.0f, 19083.5953f, 4.20148112f, 0.0997330959f },
+    { 2820.0f, 17111.7334f, 3.69847223f, 0.145325376f },
+    { 2840.0f, 15127.3494f, 3.19541756f, 0.190917649f },
+    { 2860.0f, 13171.011f, 2.69231353f, 0.236509924f },
+    { 2880.0f, 11281.1103f, 2.18917719f, 0.282102197f },
+    { 2900.0f, 9491.94511f, 1.68603374f, 0.327694472f },
+    { 2920.0f, 7832.25505f, 1.18292543f, 0.373286746f },
+    { 2940.0f, 6324.2441f, 0.679910153f, 0.418879021f },
+    { 2960.0f, 4983.10601f, 0.177063695f, 0.464471295f },
+    { 2980.0f, 3817.01902f, 5.95766834f, 0.510063569f },
+    { 3000.0f, 2827.52628f, 5.45547569f, 0.555655844f },
+    { 3020.0f, 2010.21423f, 4.95382847f, 0.601248118f },
+    { 3040.0f, 1355.58664f, 4.45294047f, 0.646840392f },
+    { 3060.0f, 850.049718f, 3.95313987f, 0.692432667f },
+    { 3080.0f, 476.939468f, 3.45505068f, 0.738024941f },
+    { 3100.0f, 217.546332f, 2.96045457f, 0.783617215f },
+    { 3120.0f, 52.1119377f, 2.4834355f, 0.82920949f },
+    { 3140.0f, 39.3097209f, 5.0750363f, 0.874801764f },
+    { 3160.0f, 75.7633798f, 4.60323668f, 0.920394038f },
+    { 3180.0f, 74.9256965f, 4.12584102f, 0.965986312f },
+    { 3200.0f, 52.2465396f, 3.66903359f, 1.01157859f },
+    { 3220.0f, 20.7094565f, 3.33469126f, 1.05717086f },
+    { 3240.0f, 12.5101404f, 5.30700152f, 1.10276314f },
+    { 3260.0f, 36.1112405f, 5.10752462f, 1.14835541f },
+    { 3280.0f, 49.7701377f, 4.67031094f, 1.19394768f },
+    { 3300.0f, 52.0993929f, 4.21026628f, 1.23953996f },
+    { 3320.0f, 44.4085673f, 3.75479764f, 1.28513223f },
+    { 3340.0f, 29.6029868f, 3.33398878f, 1.3307245f },
+    { 3360.0f, 11.7883419f, 3.12738517f, 1.37631678f },
+    { 3380.0f, 9.2784907f, 4.76106389f, 1.42190906f },
+    { 3400.0f, 23.3603942f, 4.64665936f, 1.46750133f },
+    { 3420.0f, 32.6819781f, 4.24150227f, 1.5130936f },
+    { 3440.0f, 35.5716554f, 3.79974689f, 1.55868588f },
+    { 3460.0f, 32.2062294f, 3.35857883f, 1.60427815f },
+    { 3480.0f, 23.9140004f, 2.947509f, 1.64987043f },
+    { 3500.0f, 12.9647116f, 2.66647794f, 1.6954627f },
+    { 3520.0f, 5.10443875f, 3.40284008f, 1.74105497f },
+    { 3540.0f, 11.9315509f, 4.02824031f, 1.78664725f },
+    { 3560.0f, 18.8253052f, 3.74190153f, 1.83223952f },
+    { 3580.0f, 21.8425883f, 3.34727594f, 1.8778318f },
+    { 3600.0f, 20.6668173f, 2.94177345f, 1.92342407f },
+    { 3620.0f, 16.0145209f, 2.57532135f, 1.96901635f },
+    { 3640.0f, 9.50862776f, 2.3749362f, 2.01460862f },
+    { 3660.0f, 5.28213991f, 2.90905592f, 2.0602009f },
+    { 3680.0f, 8.83107533f, 3.38482799f, 2.10579317f },
+    { 3700.0f, 13.0220485f, 3.17631661f, 2.15138545f },
+    { 3720.0f, 14.6926151f, 2.82669937f, 2.19697772f },
+    { 3740.0f, 13.4163798f, 2.46297651f, 2.24257f },
+    { 3760.0f, 9.7369505f, 2.17160914f, 2.28816227f },
+    { 3780.0f, 5.3694784f, 2.23529355f, 2.33375454f },
+    { 3800.0f, 5.45498762f, 2.98280002f, 2.37934682f },
+    { 3820.0f, 9.46455096f, 3.0075105f, 2.42493908f },
+    { 3840.0f, 12.4563717f, 2.70134515f, 2.47053137f },
+    { 3860.0f, 13.1223529f, 2.32108321f, 2.51612364f },
+    { 3880.0f, 11.268294f, 1.93885407f, 2.56171592f },
+    { 3900.0f, 7.39836586f, 1.63888244f, 2.60730819f },
+    { 3920.0f, 3.23852378f, 1.90321881f, 2.65290046f },
+    { 3940.0f, 5.13284428f, 2.85282407f, 2.69849273f },
+    { 3960.0f, 9.38536225f, 2.68181105f, 2.74408501f },
+    { 3980.0f, 12.1403244f, 2.30116063f, 2.78967728f },
+    { 4000.0f, 12.6113259f, 1.87228426f, 2.83526956f },
+    { 4020.0f, 10.6925471f, 1.43339243f, 2.88086184f },
+    { 4040.0f, 6.79347468f, 1.02015687f, 2.92645411f },
+    { 4060.0f, 1.86288551f, 0.956147783f, 2.97204638f },
+    { 4080.0f, 3.89078414f, 2.80931481f, 3.01763866f },
+    { 4100.0f, 8.36155468f, 2.46495586f, 3.06323093f },
+    { 4119.375f, 11.1796047f, 2.02595628f, 3.10739858f },
+    { 4120.0f, 11.2387289f, 2.01130744f, 3.1088233f },
+    { 4120.375f, 11.2736107f, 2.00257129f, 3.10967807f },
+    { 4121.375f, 11.361529f, 1.97887308f, 3.11195784f },
+    { 4122.375f, 11.4448828f, 1.95533119f, 3.11423738f },
+    { 4123.375f, 11.5214472f, 1.9315471f, 3.11651713f },
+    { 4124.375f, 11.5941563f, 1.90776018f, 3.1187968f },
+    { 4125.375f, 11.6589219f, 1.88397653f, 3.12107642f },
+    { 4126.375f, 11.7212649f, 1.85966187f, 3.12335654f },
+    { 4127.375f, 11.7734211f, 1.83613297f, 3.12563573f },
+    { 4128.375f, 11.8262767f, 1.81020175f, 3.12791742f },
+    { 4129.375f, 11.8633014f, 1.78787432f, 3.13019495f },
+    { 4130.375f, 11.909975f, 1.75451725f, 3.13248416f },
+    { 4131.375f, 11.9188608f, 1.73862038f, 3.13475274f },
+    { 4132.375f, 11.9341479f, 1.70588239f, 3.13475288f },
+    { 4133.375f, 11.9494349f, 1.67314441f, 3.13475303f },
+    { 4134.375f, 11.964722f, 1.64040643f, 3.13475317f },
+    { 4135.375f, 11.9800091f, 1.60766844f, 3.13475332f },
+    { 4136.375f, 11.9952962f, 1.57493046f, 3.13475346f },
+    { 4137.375f, 12.0105832f, 1.54219248f, 3.13475361f },
+    { 4138.375f, 12.0105787f, 1.55804677f, 3.13248585f },
+    { 4139.375f, 11.9915039f, 1.593459f, 3.13019475f },
+    { 4140.0f, 11.9800638f, 1.60845633f, 3.12877053f },
+    { 4140.375f, 11.9767638f, 1.61548209f, 3.12791812f },
+    { 4141.375f, 11.9496227f, 1.64269688f, 3.12563558f },
+    { 4142.375f, 11.92186f, 1.66639858f, 3.1233569f },
+    { 4143.375f, 11.8848172f, 1.69180533f, 3.12107634f },
+    { 4144.375f, 11.8450628f, 1.71612075f, 3.11879701f },
+    { 4145.375f, 11.7975442f, 1.74099954f, 3.11651708f },
+    { 4146.375f, 11.7462697f, 1.76559063f, 3.11423751f },
+    { 4147.375f, 11.6881695f, 1.79032363f, 3.11195782f },
+    { 4148.375f, 11.6256908f, 1.8150744f, 3.10967815f },
+    { 4149.375f, 11.5570047f, 1.83979024f, 3.10739857f },
+    { 4160.0f, 10.5111262f, 2.10554343f, 3.08317758f },
+    { 4180.0f, 7.17067386f, 2.62832933f, 3.03758528f },
+    { 4200.0f, 2.68716494f, 3.29272695f, 2.991993f },
+    { 4220.0f, 2.37973003f, 0.0716287913f, 2.94640071f },
+    { 4240.0f, 6.5765111f, 0.772081559f, 2.90080846f },
+    { 4260.0f, 9.49113267f, 1.31682409f, 2.85521618f },
+    { 4280.0f, 10.6066931f, 1.84890054f, 2.8096239f },
+    { 4300.0f, 9.8144314f, 2.39262019f, 2.76403163f },
+    { 4320.0f, 7.3869707f, 2.97850654f, 2.71843936f },
+    { 4340.0f, 3.99132222f, 3.73305147f, 2.67284708f },
+    { 4360.0f, 1.96261255f, 5.60518692f, 2.62725481f },
+    { 4380.0f, 4.63518247f, 0.733329315f, 2.58166253f },
+    { 4400.0f, 7.21906708f, 1.43533583f, 2.53607026f },
+    { 4420.0f, 8.53648198f, 2.049389f, 2.49047798f },
+    { 4440.0f, 8.41114078f, 2.6650379f, 2.44488571f },
+    { 4460.0f, 7.05390897f, 3.33439278f, 2.39929344f },
+    { 4480.0f, 5.05973531f, 4.15576082f, 2.35370116f },
+    { 4500.0f, 3.64410752f, 5.32908781f, 2.30810889f },
+    { 4520.0f, 4.14900714f, 0.33981335f, 2.26251662f },
+    { 4540.0f, 5.50173911f, 1.28691997f, 2.21692434f },
+    { 4560.0f, 6.39839122f, 2.06333503f, 2.17133207f },
+    { 4580.0f, 6.50309235f, 2.81467258f, 2.12573979f },
+    { 4600.0f, 5.99668061f, 3.61988351f, 2.08014752f },
+    { 4620.0f, 5.39518694f, 4.53030451f, 2.03455524f },
+    { 4640.0f, 5.26405419f, 5.51578875f, 1.98896298f },
+    { 4660.0f, 5.64513327f, 0.173450758f, 1.9433707f },
+    { 4680.0f, 6.0458767f, 1.02365068f, 1.89777842f },
+    { 4700.0f, 6.04562476f, 1.83043655f, 1.85218615f },
+    { 4720.0f, 5.58239452f, 2.66372258f, 1.80659387f },
+    { 4740.0f, 4.97978086f, 3.59195004f, 1.7610016f },
+    { 4760.0f, 4.80903081f, 4.61848768f, 1.71540932f },
+    { 4780.0f, 5.30965715f, 5.61209482f, 1.66981705f },
+    { 4800.0f, 6.04613584f, 0.203120409f, 1.62422477f },
+    { 4820.0f, 6.48043012f, 0.996153551f, 1.57863249f },
+    { 4840.0f, 6.36431627f, 1.77227969f, 1.53304022f },
+    { 4860.0f, 5.78230222f, 2.5923506f, 1.48744795f },
+    { 4880.0f, 5.12184731f, 3.50858513f, 1.44185568f },
+    { 4900.0f, 4.88109962f, 4.50724083f, 1.3962634f },
+    { 4920.0f, 5.15313391f, 5.47431506f, 1.35067113f },
+    { 4940.0f, 5.49148987f, 0.0664110541f, 1.30507885f },
+    { 4960.0f, 5.46085415f, 0.895339252f, 1.25948659f },
+    { 4980.0f, 4.99084724f, 1.76018895f, 1.2138943f },
+    { 5000.0f, 4.47702225f, 2.74545119f, 1.16830203f },
+    { 5020.0f, 4.60863414f, 3.81908003f, 1.12270975f },
+    { 5040.0f, 5.48043558f, 4.78432616f, 1.07711748f },
+    { 5060.0f, 6.38749742f, 5.58829137f, 1.03152521f },
+    { 5080.0f, 6.65113191f, 0.0167705434f, 0.985932933f },
+    { 5100.0f, 5.92288597f, 0.705891561f, 0.940340658f },
+    { 5120.0f, 4.23174474f, 1.47237798f, 0.894748383f },
+    { 5140.0f, 2.36929989f, 2.7014122f, 0.84915613f },
+    { 5160.0f, 3.22694405f, 4.43296544f, 0.803563836f },
+    { 5180.0f, 5.79424221f, 5.34472415f, 0.757971561f },
+    { 5200.0f, 7.88528469f, 5.99870593f, 0.712379287f },
+    { 5220.0f, 8.76322848f, 0.299826303f, 0.666787012f },
+    { 5240.0f, 8.10153363f, 0.861912625f, 0.621194735f },
+    { 5260.0f, 5.90618171f, 1.43169141f, 0.57560246f },
+    { 5280.0f, 2.53939049f, 2.12533799f, 0.530010188f },
+    { 5300.0f, 1.78732309f, 5.07001079f, 0.484417915f },
+    { 5320.0f, 5.61932133f, 5.87767593f, 0.438825641f },
+    { 5340.0f, 8.65381307f, 0.155536553f, 0.393233366f },
+    { 5360.0f, 10.1759854f, 0.68555264f, 0.347641092f },
+    { 5380.0f, 9.81411452f, 1.20797262f, 0.302048814f },
+    { 5400.0f, 7.55902245f, 1.73424267f, 0.256456543f },
+    { 5420.0f, 3.78239912f, 2.29869717f, 0.210864279f },
+    { 5440.0f, 4.63857708f, 1.14630134f, 0.165272002f },
+    { 5460.0f, 5.49475503f, 6.27709082f, 0.119679725f },
+    { 5480.0f, 9.16156756f, 0.534437637f, 0.0740874385f },
+    { 5497.5f, 11.0124238f, 0.991856358f, 0.0341940806f },
+    { 5498.5f, 11.0718582f, 1.01774206f, 0.0319146296f },
+    { 5499.5f, 11.1253697f, 1.04395687f, 0.02963481f },
+    { 5500.0f, 11.1502754f, 1.05675729f, 0.0284952421f },
+    { 5500.5f, 11.1743008f, 1.06983898f, 0.0273553638f },
+    { 5501.5f, 11.2167021f, 1.09608495f, 0.0250755108f },
+    { 5502.5f, 11.2551688f, 1.12204311f, 0.022795997f },
+    { 5503.5f, 11.2859508f, 1.14824545f, 0.0205162041f },
+    { 5504.5f, 11.3143181f, 1.1745312f, 0.0182363648f },
+    { 5505.5f, 11.3325206f, 1.20050887f, 0.0159568703f },
+    { 5506.5f, 11.3517119f, 1.2280502f, 0.0136757602f },
+    { 5507.5f, 11.354387f, 1.25299568f, 0.0113976063f },
+    { 5508.5f, 11.3680435f, 1.28698768f, 0.00910994856f },
+    { 5509.5f, 11.3382346f, 1.30557071f, 0.00684031108f },
+    { 5510.5f, 11.3227723f, 1.36877938f, 0.00684003328f },
+    { 5511.5f, 11.3073099f, 1.43198805f, 0.00683975547f },
+    { 5512.5f, 11.2918476f, 1.49519673f, 0.00683947766f },
+    { 5513.5f, 11.2763853f, 1.5584054f, 0.00683919986f },
+    { 5514.5f, 11.260923f, 1.62161407f, 0.00683892205f },
+    { 5515.5f, 11.2454607f, 1.68482275f, 0.00683864424f },
+    { 5516.5f, 11.2052625f, 1.66686986f, 0.00910660458f },
+    { 5517.5f, 11.1554866f, 1.62940842f, 0.0113980008f },
+    { 5518.5f, 11.1068277f, 1.60579545f, 0.0136743819f },
+    { 5519.5f, 11.0480255f, 1.576597f, 0.0159571478f },
+    { 5520.0f, 11.0176139f, 1.56452371f, 0.0170957291f },
+    { 5520.5f, 10.9876326f, 1.5512809f, 0.0182356481f },
+    { 5521.5f, 10.9187724f, 1.52399504f, 0.0205163545f },
+    { 5522.5f, 10.8468972f, 1.4980317f, 0.0227955825f },
+    { 5523.5f, 10.7677559f, 1.47134302f, 0.0250755984f },
+    { 5524.5f, 10.6846866f, 1.44509074f, 0.0273551095f },
+    { 5525.5f, 10.5951299f, 1.41860592f, 0.0296348432f },
+    { 5526.5f, 10.5012005f, 1.39219334f, 0.031914472f },
+    { 5527.5f, 10.4012375f, 1.36575281f, 0.0341940895f },
+    { 5540.0f, 8.73239727f, 1.03099682f, 0.0626893829f },
+    { 5560.0f, 4.6965725f, 0.448439279f, 0.108281658f },
+    { 5580.0f, 5.14671241f, 1.64077175f, 0.153873929f },
+    { 5600.0f, 5.59685232f, 2.83310423f, 0.199466201f },
+    { 5620.0f, 9.74555536f, 2.26060216f, 0.245058477f },
+    { 5640.0f, 12.1213611f, 1.72049318f, 0.290650749f },
+    { 5660.0f, 12.2239247f, 1.18095598f, 0.336243025f },
+    { 5680.0f, 10.0097007f, 0.624117548f, 0.3818353f },
+    { 5700.0f, 5.92810273f, 6.27812112f, 0.427427572f },
+    { 5720.0f, 1.53247665f, 4.73588668f, 0.473019841f },
+    { 5740.0f, 5.13185504f, 2.61791536f, 0.51861212f },
+    { 5760.0f, 9.4584036f, 1.94840794f, 0.564204395f },
+    { 5780.0f, 12.0337869f, 1.36749932f, 0.609796669f },
+    { 5800.0f, 12.3003953f, 0.794371759f, 0.655388944f },
+    { 5820.0f, 10.2263474f, 0.194380161f, 0.700981218f },
+    { 5840.0f, 6.35155539f, 5.76255025f, 0.746573488f },
+    { 5860.0f, 2.71475856f, 4.26954628f, 0.792165774f },
+    { 5880.0f, 5.53711471f, 2.4678478f, 0.837758041f },
+    { 5900.0f, 9.62287959f, 1.69267836f, 0.883350315f },
+    { 5920.0f, 12.1001903f, 1.06486719f, 0.92894259f },
+    { 5940.0f, 12.3137837f, 0.459377427f, 0.974534864f },
+    { 5960.0f, 10.2314751f, 6.10893408f, 1.02012713f },
+    { 5980.0f, 6.45409403f, 5.33650867f, 1.06571941f },
+    { 6000.0f, 3.35315096f, 3.81968223f, 1.11131169f },
+    { 6020.0f, 6.20042954f, 2.20079072f, 1.15690396f },
+    { 6040.0f, 10.2958627f, 1.40171695f, 1.20249623f },
+    { 6060.0f, 12.9239216f, 0.759861104f, 1.24808851f },
+    { 6080.0f, 13.3771738f, 0.151681305f, 1.29368078f },
+    { 6100.0f, 11.5643086f, 5.8165364f, 1.33927306f },
+    { 6120.0f, 7.92529809f, 5.12318487f, 1.38486533f },
+    { 6140.0f, 3.7707546f, 4.02127778f, 1.43045761f },
+    { 6160.0f, 4.38931884f, 2.02239765f, 1.47604988f },
+    { 6180.0f, 8.50540039f, 1.06319767f, 1.52164216f },
+    { 6200.0f, 11.6952373f, 0.392630845f, 1.56723443f },
+    { 6220.0f, 13.0687514f, 6.06390166f, 1.6128267f },
+    { 6240.0f, 12.4286204f, 5.46141372f, 1.65841898f },
+    { 6260.0f, 10.0019813f, 4.83772514f, 1.70401125f },
+    { 6280.0f, 6.38261985f, 4.1245788f, 1.74960352f },
+    { 6300.0f, 2.85643922f, 2.92566307f, 1.7951958f },
+    { 6320.0f, 3.73107531f, 0.959477719f, 1.84078807f },
+    { 6340.0f, 6.79914669f, 0.0411795223f, 1.88638035f },
+    { 6360.0f, 8.98649222f, 5.65111399f, 1.93197263f },
+    { 6380.0f, 9.82758751f, 5.03017089f, 1.9775649f },
+    { 6400.0f, 9.31744708f, 4.41943479f, 2.02315717f },
+    { 6420.0f, 7.68962823f, 3.79646578f, 2.06874945f },
+    { 6440.0f, 5.3318297f, 3.12489912f, 2.11434172f },
+    { 6460.0f, 2.78020068f, 2.25597027f, 2.15993399f },
+    { 6480.0f, 1.58627325f, 0.418664825f, 2.20552627f },
+    { 6500.0f, 3.20589171f, 5.32582953f, 2.25111855f },
+    { 6520.0f, 4.87192342f, 4.57554982f, 2.29671081f },
+    { 6540.0f, 5.92241045f, 3.94702157f, 2.34230309f },
+    { 6560.0f, 6.25409919f, 3.36364237f, 2.38789537f },
+    { 6580.0f, 5.88510138f, 2.80750897f, 2.43348764f },
+    { 6600.0f, 4.9015302f, 2.27415906f, 2.47907992f },
+    { 6620.0f, 3.43755227f, 1.76594745f, 2.52467219f },
+    { 6640.0f, 1.66189998f, 1.30822408f, 2.57026447f },
+    { 6660.0f, 1.87910986f, 2.30913416f, 2.61585674f },
+    { 6680.0f, 2.09631974f, 3.31004423f, 2.66144901f },
+    { 6700.0f, 3.6717454f, 2.87288527f, 2.70704129f },
+    { 6720.0f, 4.81057921f, 2.42307796f, 2.75263356f },
+    { 6740.0f, 5.36496554f, 1.97553593f, 2.79822583f },
+    { 6760.0f, 5.2387853f, 1.53543266f, 2.84381811f },
+    { 6780.0f, 4.41348717f, 1.11240289f, 2.88941039f },
+    { 6800.0f, 2.97570972f, 0.742064963f, 2.93500266f },
+    { 6820.0f, 1.21481208f, 0.697617525f, 2.98059492f },
+    { 6840.0f, 1.38236164f, 2.13185506f, 3.02618721f },
+    { 6860.0f, 3.21123422f, 2.01150176f, 3.07177948f },
+    { 6875.625f, 4.39759189f, 1.71770491f, 3.10739856f },
+    { 6876.625f, 4.46072333f, 1.69727463f, 3.10967821f },
+    { 6877.625f, 4.52175352f, 1.67675407f, 3.11195781f },
+    { 6878.625f, 4.58134717f, 1.6560069f, 3.11423755f },
+    { 6879.625f, 4.63855562f, 1.63534967f, 3.11651705f },
+    { 6880.0f, 4.65996759f, 1.62736014f, 3.11737211f },
+    { 6880.625f, 4.69457589f, 1.61410624f, 3.11879709f },
+    { 6881.625f, 4.74783969f, 1.59353074f, 3.12107627f },
+    { 6882.625f, 4.80016991f, 1.57143509f, 3.12335702f },
+    { 6883.625f, 4.84927552f, 1.55125883f, 3.1256355f },
+    { 6884.625f, 4.89807009f, 1.52707426f, 3.12791828f },
+    { 6885.625f, 4.94277857f, 1.50840152f, 3.13019464f },
+    { 6886.625f, 4.98835568f, 1.47577129f, 3.13248605f },
+    { 6887.625f, 5.02988139f, 1.46259301f, 3.13475399f },
+    { 6888.625f, 5.06188968f, 1.51929891f, 3.13475374f },
+    { 6889.625f, 5.09389798f, 1.57600481f, 3.13475348f },
+    { 6890.625f, 5.12590628f, 1.6327107f, 3.13475323f },
+    { 6891.625f, 5.15791457f, 1.6894166f, 3.13475297f },
+    { 6892.625f, 5.18992287f, 1.7461225f, 3.13475272f },
+    { 6893.625f, 5.22193116f, 1.8028284f, 3.13475247f },
+    { 6894.625f, 5.26060752f, 1.81677043f, 3.1324833f },
+    { 6895.625f, 5.28067036f, 1.84708403f, 3.13019501f },
+    { 6896.625f, 5.30585258f, 1.86754484f, 3.12791714f },
+    { 6897.625f, 5.32381866f, 1.89112632f, 3.12563577f },
+    { 6898.625f, 5.34240729f, 1.91281687f, 3.12335642f },
+    { 6899.625f, 5.35660028f, 1.9351037f, 3.12107644f },
+    { 6900.0f, 5.36221677f, 1.94315892f, 3.12022176f },
+    { 6900.625f, 5.36989691f, 1.95712459f, 3.11879674f },
+    { 6901.625f, 5.37974421f, 1.97907117f, 3.11651714f },
+    { 6902.625f, 5.38804838f, 2.00119852f, 3.11423735f },
+    { 6903.625f, 5.39344895f, 2.0231044f, 3.11195783f },
+    { 6904.625f, 5.39684122f, 2.04524339f, 3.10967806f },
+    { 6905.625f, 5.39757447f, 2.06713715f, 3.10739858f },
+    { 6920.0f, 5.14680315f, 2.38359369f, 3.07462899f },
+    { 6940.0f, 4.01524041f, 2.8112696f, 3.02903673f },
+    { 6960.0f, 2.16043027f, 3.15718263f, 2.98344445f },
+    { 6980.0f, 2.36969554f, 2.28488305f, 2.93785218f },
+    { 7000.0f, 2.5789608f, 1.41258346f, 2.8922599f },
+    { 7020.0f, 4.42268779f, 1.78492878f, 2.84666763f },
+    { 7040.0f, 5.48420165f, 2.21250951f, 2.80107536f },
+    { 7060.0f, 5.53913922f, 2.64260026f, 2.75548308f },
+    { 7080.0f, 4.57400644f, 3.04603275f, 2.70989081f },
+    { 7100.0f, 2.81239277f, 3.34109085f, 2.66429853f },
+    { 7120.0f, 1.10993858f, 2.83072277f, 2.61870624f },
+    { 7140.0f, 2.44325174f, 1.95109402f, 2.57311398f },
+    { 7160.0f, 4.36433644f, 2.17505835f, 2.52752171f },
+    { 7180.0f, 5.62052741f, 2.5298559f, 2.48192944f },
+    { 7200.0f, 5.95136461f, 2.89335479f, 2.43633716f },
+    { 7220.0f, 5.36455114f, 3.21585715f, 2.39074489f },
+    { 7240.0f, 4.14098475f, 3.42187951f, 2.34515261f },
+    { 7260.0f, 2.97414574f, 3.34259723f, 2.29956033f },
+    { 7280.0f, 3.00408569f, 3.00119894f, 2.25396806f },
+    { 7300.0f, 4.06715175f, 2.93306351f, 2.20837579f },
+    { 7320.0f, 5.06457668f, 3.09256226f, 2.16278351f },
+    { 7340.0f, 5.54027905f, 3.31395239f, 2.11719125f },
+    { 7360.0f, 5.47452618f, 3.51726848f, 2.07159896f },
+    { 7380.0f, 5.10619531f, 3.6552932f, 2.02600669f },
+    { 7400.0f, 4.80260858f, 3.71471938f, 1.98041442f },
+    { 7420.0f, 4.81233547f, 3.74343483f, 1.93482214f },
+    { 7440.0f, 5.05174286f, 3.80831733f, 1.88922987f },
+    { 7460.0f, 5.26116069f, 3.92045993f, 1.8436376f },
+    { 7480.0f, 5.28309848f, 4.0490981f, 1.79804532f },
+    { 7500.0f, 5.14473756f, 4.16066118f, 1.75245304f },
+    { 7520.0f, 4.9945374f, 4.24001102f, 1.70686077f },
+    { 7540.0f, 4.970041f, 4.30063564f, 1.66126849f },
+    { 7560.0f, 5.08815883f, 4.37149134f, 1.61567622f },
+    { 7580.0f, 5.26292423f, 4.46890835f, 1.57008395f },
+    { 7600.0f, 5.40507007f, 4.5913f, 1.52449167f },
+    { 7620.0f, 5.46446614f, 4.73250765f, 1.4788994f },
+    { 7640.0f, 5.40102017f, 4.88912412f, 1.43330712f },
+    { 7660.0f, 5.15225245f, 5.05563837f, 1.38771485f },
+    { 7680.0f, 4.66051989f, 5.21246253f, 1.34212258f },
+    { 7700.0f, 3.96697774f, 5.31121544f, 1.2965303f },
+    { 7720.0f, 3.35819755f, 5.27288982f, 1.25093801f },
+    { 7740.0f, 3.37521182f, 5.11988789f, 1.20534575f },
+    { 7760.0f, 4.13411729f, 5.09213628f, 1.15975348f },
+    { 7780.0f, 5.06662746f, 5.26235181f, 1.11416121f },
+    { 7800.0f, 5.62180818f, 5.55323228f, 1.06856893f },
+    { 7820.0f, 5.47952158f, 5.90366735f, 1.02297665f },
+    { 7840.0f, 4.52963594f, 6.2708832f, 0.977384381f },
+    { 7860.0f, 2.87546381f, 0.298765884f, 0.931792105f },
+    { 7880.0f, 1.06581105f, 0.004837503f, 0.886199822f },
+    { 7900.0f, 2.08934186f, 5.17048881f, 0.840607558f },
+    { 7920.0f, 4.07459601f, 5.41846068f, 0.795015284f },
+    { 7940.0f, 5.50458575f, 5.84658045f, 0.749423013f },
+    { 7960.0f, 6.04525037f, 0.0400730742f, 0.703830734f },
+    { 7980.0f, 5.57445899f, 0.54094459f, 0.658238461f },
+    { 8000.0f, 4.16007839f, 1.06148172f, 0.612646186f },
+    { 8020.0f, 2.04254636f, 1.62209782f, 0.567053907f },
+    { 8040.0f, 2.43012995f, 0.508535029f, 0.521461636f },
+    { 8060.0f, 2.81771354f, 5.67815755f, 0.475869365f },
+    { 8080.0f, 4.7193596f, 6.23757592f, 0.430277083f },
+    { 8100.0f, 5.82779149f, 0.500774946f, 0.384684815f },
+    { 8120.0f, 5.97011109f, 1.04530942f, 0.33909254f },
+    { 8140.0f, 5.14161473f, 1.59014073f, 0.293500268f },
+    { 8160.0f, 3.50148252f, 2.13609395f, 0.247907992f },
+    { 8180.0f, 1.34092133f, 2.68843675f, 0.202315683f },
+    { 8200.0f, 2.19358409f, 1.64807102f, 0.156723425f },
+    { 8220.0f, 3.04624684f, 0.607705293f, 0.111131167f },
+    { 8240.0f, 4.55332106f, 1.14358896f, 0.0655389002f },
+    { 8253.75f, 5.13546825f, 1.50632682f, 0.0341941098f },
+    { 8254.75f, 5.16197471f, 1.5325254f, 0.031914433f },
+    { 8255.75f, 5.18591012f, 1.55860502f, 0.0296348673f },
+    { 8256.75f, 5.20807793f, 1.58486683f, 0.0273550493f },
+    { 8257.75f, 5.2275074f, 1.6107223f, 0.0250756589f },
+    { 8258.75f, 5.24531097f, 1.63723856f, 0.0227954956f },
+    { 8259.75f, 5.26017385f, 1.66271676f, 0.0205164461f },
+    { 8260.0f, 5.26385512f, 1.67011879f, 0.0199455476f },
+    { 8260.75f, 5.27368565f, 1.68986424f, 0.0182355292f },
+    { 8261.75f, 5.28402829f, 1.71460446f, 0.0159572778f },
+    { 8262.75f, 5.29329505f, 1.74358147f, 0.0136743201f },
+    { 8263.75f, 5.29956415f, 1.76660477f, 0.0113981644f },
+    { 8264.75f, 5.30446287f, 1.80332496f, 0.00910699761f },
+    { 8265.75f, 5.31179703f, 1.82170619f, 0.00683803287f },
+    { 8266.75f, 5.30208857f, 1.71332262f, 0.00683848749f },
+    { 8267.75f, 5.2923801f, 1.60493905f, 0.00683894212f },
+    { 8268.75f, 5.28267164f, 1.49655548f, 0.00683939675f },
+    { 8269.75f, 5.27296318f, 1.38817191f, 0.00683985137f },
+    { 8270.75f, 5.26325472f, 1.27978834f, 0.006840306f },
+    { 8271.75f, 5.25354626f, 1.17140477f, 0.00684076063f },
+    { 8272.75f, 5.25670096f, 1.1522904f, 0.0091124045f },
+    { 8273.75f, 5.23656498f, 1.12147562f, 0.0113975269f },
+    { 8274.75f, 5.22254566f, 1.09670572f, 0.0136765332f },
+    { 8275.75f, 5.20097788f, 1.07084388f, 0.0159568177f },
+    { 8276.75f, 5.18030654f, 1.04552864f, 0.018236695f },
+    { 8277.75f, 5.15541976f, 1.0206194f, 0.0205161853f },
+    { 8278.75f, 5.12973705f, 0.995392105f, 0.0227961586f },
+    { 8279.75f, 5.10108709f, 0.970784569f, 0.0250755116f },
+    { 8280.0f, 5.0938745f, 0.964230159f, 0.0256458314f },
+    { 8280.75f, 5.07099128f, 0.945760501f, 0.0273554462f },
+    { 8281.75f, 5.03836542f, 0.921337656f, 0.0296348043f },
+    { 8282.75f, 5.00408222f, 0.896545406f, 0.0319146741f },
+    { 8283.75f, 4.96766945f, 0.872258173f, 0.0341940933f },
+    { 8300.0f, 4.12084436f, 0.492305928f, 0.071237925f },
+    { 8320.0f, 2.58837422f, 0.126978577f, 0.116830195f },
+    { 8340.0f, 1.11383885f, 0.352338291f, 0.162422479f },
+    { 8360.0f, 1.73100135f, 1.22785902f, 0.208014741f },
+    { 8380.0f, 3.06909839f, 1.03269664f, 0.253607052f },
+    { 8400.0f, 3.90629429f, 0.653024734f, 0.2991993f },
+    { 8420.0f, 4.05624643f, 0.26183099f, 0.344791564f },
+    { 8440.0f, 3.58221522f, 6.21042261f, 0.390383829f },
+    { 8460.0f, 2.78231508f, 6.02755543f, 0.435976123f },
+    { 8480.0f, 2.25827753f, 6.11454218f, 0.481568447f },
+    { 8500.0f, 2.51170666f, 6.25155459f, 0.527160672f },
+    { 8520.0f, 3.07296334f, 6.15186931f, 0.572752946f },
+    { 8540.0f, 3.3558073f, 5.92602749f, 0.618345221f },
+    { 8560.0f, 3.19779778f, 5.71043592f, 0.663937504f },
+    { 8580.0f, 2.81729101f, 5.6226835f, 0.709529769f },
+    { 8600.0f, 2.76870284f, 5.6952611f, 0.755122044f },
+    { 8620.0f, 3.35070095f, 5.69774042f, 0.800714336f },
+    { 8640.0f, 4.11191119f, 5.50807869f, 0.846306592f },
+    { 8660.0f, 4.51971078f, 5.20783758f, 0.891898873f },
+    { 8680.0f, 4.29387139f, 4.88102083f, 0.937491141f },
+    { 8700.0f, 3.42792522f, 4.61913246f, 0.983083415f },
+    { 8720.0f, 2.34560827f, 4.63911487f, 1.02867569f },
+    { 8740.0f, 2.37865208f, 5.0836326f, 1.07426795f },
+    { 8760.0f, 3.78299113f, 5.12393898f, 1.11986024f },
+    { 8780.0f, 5.23406294f, 4.83799796f, 1.16545253f },
+    { 8800.0f, 6.07476606f, 4.44980261f, 1.21104479f },
+    { 8820.0f, 6.02860567f, 4.03575961f, 1.25663706f },
+    { 8840.0f, 5.06095695f, 3.64508114f, 1.30222934f },
+    { 8860.0f, 3.40758734f, 3.37869207f, 1.34782162f },
+    { 8880.0f, 1.96573768f, 3.64923048f, 1.39341389f },
+    { 8900.0f, 2.83451794f, 4.2033661f, 1.43900616f },
+    { 8920.0f, 4.67528363f, 4.03946585f, 1.48459843f },
+    { 8940.0f, 6.03845101f, 3.66591078f, 1.53019071f },
+    { 8960.0f, 6.50323825f, 3.24202196f, 1.57578298f },
+    { 8980.0f, 5.96506249f, 2.82101045f, 1.62137526f },
+    { 9000.0f, 4.56825881f, 2.45871901f, 1.66696753f },
+    { 9020.0f, 2.786547f, 2.32420435f, 1.71255978f },
+    { 9040.0f, 2.07000043f, 2.8427075f, 1.75815209f },
+    { 9060.0f, 3.38008917f, 3.05274328f, 1.80374435f },
+    { 9080.0f, 4.77531908f, 2.78485286f, 1.84933665f },
+    { 9100.0f, 5.4328992f, 2.39653335f, 1.8949289f },
+    { 9120.0f, 5.15561253f, 1.98766526f, 1.94052117f },
+    { 9140.0f, 4.03452447f, 1.62097992f, 1.98611345f },
+    { 9160.0f, 2.45933331f, 1.45143834f, 2.03170572f },
+    { 9180.0f, 1.64246685f, 1.97502089f, 2.077298f },
+    { 9200.0f, 2.714958f, 2.26973137f, 2.12289027f },
+    { 9220.0f, 3.88211842f, 2.00904911f, 2.16848254f },
+    { 9240.0f, 4.34572016f, 1.61204f, 2.21407482f },
+    { 9260.0f, 3.93498701f, 1.1836919f, 2.2596671f },
+    { 9280.0f, 2.74487838f, 0.783548335f, 2.30525937f },
+    { 9300.0f, 1.1259517f, 0.664707004f, 2.35085165f },
+    { 9320.0f, 1.14883016f, 2.12871024f, 2.39644394f },
+    { 9340.0f, 2.65826465f, 1.98022389f, 2.44203619f },
+    { 9360.0f, 3.65343281f, 1.55565147f, 2.48762847f },
+    { 9380.0f, 3.85080885f, 1.08193782f, 2.53322074f },
+    { 9400.0f, 3.21350348f, 0.589476097f, 2.57881302f },
+    { 9420.0f, 1.89444415f, 0.0808481599f, 2.6244053f },
+    { 9440.0f, 1.70592265f, 1.18957162f, 2.66999757f },
+    { 9460.0f, 1.51740115f, 2.29829508f, 2.71558985f },
+    { 9480.0f, 2.86136084f, 1.78209156f, 2.76118211f },
+    { 9500.0f, 3.56134227f, 1.28300664f, 2.80677439f },
+    { 9520.0f, 3.48237156f, 0.79318444f, 2.85236666f },
+    { 9540.0f, 2.66138217f, 0.318805565f, 2.89795894f },
+    { 9560.0f, 1.29606104f, 6.18673643f, 2.94355114f },
+    { 9580.0f, 1.58081299f, 0.87334981f, 2.98914345f },
+    { 9600.0f, 1.86556494f, 1.8431485f, 3.03473576f },
+    { 9620.0f, 2.97858755f, 1.41135079f, 3.08032808f },
+    { 9631.875f, 3.35797489f, 1.14664835f, 3.10739843f },
+    { 9632.875f, 3.37916022f, 1.12417753f, 3.10967828f },
+    { 9633.875f, 3.39855248f, 1.10219911f, 3.11195761f },
+    { 9634.875f, 3.41627999f, 1.07963253f, 3.11423763f },
+    { 9635.875f, 3.43229443f, 1.05785321f, 3.11651678f },
+    { 9636.875f, 3.44646f, 1.035084f, 3.11879707f },
+    { 9637.875f, 3.45911061f, 1.0136291f, 3.12107591f },
+    { 9638.875f, 3.46968427f, 0.990469045f, 3.12335671f },
+    { 9639.875f, 3.47922404f, 0.9695724f, 3.12563497f },
+    { 9640.0f, 3.47971572f, 0.966905099f, 3.12591983f },
+    { 9640.875f, 3.48601195f, 0.945465003f, 3.12791689f },
+    { 9641.875f, 3.49363556f, 0.925484308f, 3.13019407f },
+    { 9642.875f, 3.49541496f, 0.898734199f, 3.13247903f },
+    { 9643.875f, 3.5093991f, 0.878097543f, 3.13475597f },
+    { 9644.875f, 3.49846256f, 0.834999981f, 3.13705906f },
+    { 9645.875f, 3.49400404f, 1.22127607f, 3.13704963f },
+    { 9646.875f, 3.48954552f, 1.60755216f, 3.13704019f },
+    { 9647.875f, 3.485087f, 1.99382825f, 3.13703076f },
+    { 9648.875f, 3.48062848f, 2.38010434f, 3.13702132f },
+    { 9649.875f, 3.45996942f, 2.39350363f, 3.13475148f },
+    { 9650.875f, 3.4624264f, 2.41510447f, 3.13247075f },
+    { 9651.875f, 3.44851262f, 2.43300627f, 3.13019513f },
+    { 9652.875f, 3.43737889f, 2.45607662f, 3.12791344f },
+    { 9653.875f, 3.42177728f, 2.47561531f, 3.12563578f },
+    { 9654.875f, 3.40567553f, 2.49789752f, 3.12335492f },
+    { 9655.875f, 3.38718031f, 2.5180565f, 3.12107637f },
+    { 9656.875f, 3.36738436f, 2.53971409f, 3.11879603f },
+    { 9657.875f, 3.34579129f, 2.56005557f, 3.11651705f },
+    { 9658.875f, 3.32270149f, 2.58129753f, 3.11423698f },
+    { 9659.875f, 3.29799443f, 2.60169408f, 3.11195773f },
+    { 9660.0f, 3.29469049f, 2.60434344f, 3.11167271f },
+    { 9660.875f, 3.27170901f, 2.62256101f, 3.10967784f },
+    { 9661.875f, 3.24390861f, 2.64280566f, 3.10739849f },
+    { 9680.0f, 2.50115487f, 2.98375767f, 3.06608044f },
+    { 9700.0f, 1.33817839f, 3.16268258f, 3.02048817f },
+    { 9720.0f, 1.59027028f, 2.51283416f, 2.97489592f },
+    { 9740.0f, 1.84236217f, 1.86298574f, 2.92930366f },
+    { 9760.0f, 2.86274388f, 2.14647032f, 2.88371136f },
+    { 9780.0f, 3.46055461f, 2.51605451f, 2.83811908f },
+    { 9800.0f, 3.54661182f, 2.90208423f, 2.7925268f },
+    { 9820.0f, 3.13537789f, 3.2799506f, 2.74693453f },
+    { 9840.0f, 2.31519322f, 3.61890581f, 2.70134225f },
+    { 9860.0f, 1.25336082f, 3.78884269f, 2.65574998f },
+    { 9880.0f, 1.43774489f, 3.1124847f, 2.6101577f },
+    { 9900.0f, 1.62212896f, 2.43612671f, 2.56456543f },
+    { 9920.0f, 2.68507549f, 2.72629013f, 2.51897316f },
+    { 9940.0f, 3.46296109f, 3.13912426f, 2.47338088f },
+    { 9960.0f, 3.81447755f, 3.60614332f, 2.42778861f },
+    { 9980.0f, 3.67041447f, 4.11728905f, 2.38219633f },
+    { 10000.0f, 3.03924688f, 4.6851548f, 2.33660406f },
+    { 10020.0f, 2.02764026f, 5.37309263f, 2.29101179f },
+    { 10040.0f, 1.68414072f, 0.637391505f, 2.24541951f },
+    { 10060.0f, 1.34064117f, 2.18487569f, 2.19982723f },
+    { 10080.0f, 2.54222467f, 3.13984022f, 2.15423496f },
+    { 10100.0f, 3.60204005f, 3.86285675f, 2.10864269f },
+    { 10120.0f, 4.3011632f, 4.54882203f, 2.06305042f },
+    { 10140.0f, 4.56066145f, 5.24274384f, 2.01745814f },
+    { 10160.0f, 4.38249571f, 5.96888646f, 1.97186587f },
+    { 10180.0f, 3.84810529f, 0.474751984f, 1.92627359f },
+    { 10200.0f, 3.14762158f, 1.38362324f, 1.88068132f },
+    { 10220.0f, 2.65473066f, 2.48589297f, 1.83508904f },
+    { 10240.0f, 2.81302762f, 3.68463185f, 1.78949676f },
+    { 10260.0f, 3.53355332f, 4.72817996f, 1.74390449f },
+    { 10280.0f, 4.34431663f, 5.60769472f, 1.69831222f },
+    { 10300.0f, 4.90917098f, 0.122921754f, 1.65271994f },
+    { 10320.0f, 5.06500748f, 0.896276075f, 1.60712767f },
+    { 10340.0f, 4.79076987f, 1.68503405f, 1.56153539f },
+    { 10360.0f, 4.20878504f, 2.53165662f, 1.51594312f },
+    { 10380.0f, 3.58923468f, 3.48281007f, 1.47035085f },
+    { 10400.0f, 3.27404426f, 4.53916069f, 1.42475857f },
+    { 10420.0f, 3.3827507f, 5.59135674f, 1.37916631f },
+    { 10440.0f, 3.66078837f, 0.268510492f, 1.33357402f },
+    { 10460.0f, 3.8180682f, 1.16174284f, 1.28798174f },
+    { 10480.0f, 3.76454449f, 2.04472942f, 1.24238947f },
+    { 10500.0f, 3.6004818f, 2.95810532f, 1.1967972f },
+    { 10520.0f, 3.50018516f, 3.90091709f, 1.15120492f },
+    { 10540.0f, 3.52374948f, 4.82567474f, 1.10561266f },
+    { 10560.0f, 3.53040993f, 5.69263113f, 1.06002038f },
+    { 10580.0f, 3.31592645f, 0.228729332f, 1.01442811f },
+    { 10600.0f, 2.78181658f, 1.05434752f, 0.96883583f },
+    { 10620.0f, 2.0418351f, 2.00747424f, 0.923243555f },
+    { 10640.0f, 1.59851905f, 3.29694243f, 0.877651281f },
+    { 10660.0f, 2.02924671f, 4.58432723f, 0.832059014f },
+    { 10680.0f, 2.80361807f, 5.4823803f, 0.786466733f },
+    { 10700.0f, 3.33259662f, 6.18559362f, 0.740874458f },
+    { 10720.0f, 3.37663424f, 0.523268211f, 0.695282179f },
+    { 10740.0f, 2.88252554f, 1.10362482f, 0.649689908f },
+    { 10760.0f, 1.92814091f, 1.66640452f, 0.604097649f },
+    { 10780.0f, 1.87930509f, 1.10023776f, 0.558505381f },
+    { 10800.0f, 1.83046928f, 0.534071004f, 0.512913113f },
+    { 10820.0f, 1.78163347f, 6.25108955f, 0.467320845f },
+    { 10840.0f, 2.59165753f, 0.467663891f, 0.421728531f },
+    { 10860.0f, 2.95013887f, 0.942205495f, 0.376136263f },
+    { 10880.0f, 2.83099608f, 1.39451357f, 0.33054399f },
+    { 10900.0f, 2.2898106f, 1.81410941f, 0.284951714f },
+    { 10920.0f, 1.45236147f, 2.15201163f, 0.23935944f },
+    { 10940.0f, 1.50640394f, 1.75669732f, 0.193767166f },
+    { 10960.0f, 1.56044641f, 1.36138302f, 0.148174892f },
+    { 10980.0f, 1.61448888f, 0.966068708f, 0.102582618f },
+    { 11000.0f, 2.19519921f, 1.3447089f, 0.0569903008f },
+    { 11010.0f, 2.35880346f, 1.5587306f, 0.0341941202f },
+    { 11011.0f, 2.37013588f, 1.58079413f, 0.0319144048f },
+    { 11012.0f, 2.38030975f, 1.60279497f, 0.0296348788f },
+    { 11013.0f, 2.38971882f, 1.62518726f, 0.0273550179f },
+    { 11014.0f, 2.39795519f, 1.64716441f, 0.0250756939f },
+    { 11015.0f, 2.40552164f, 1.67005586f, 0.0227954909f },
+    { 11016.0f, 2.41175824f, 1.69198311f, 0.0205164665f },
+    { 11017.0f, 2.41745711f, 1.71571159f, 0.0182355497f },
+    { 11018.0f, 2.4217849f, 1.73717734f, 0.0159572881f },
+    { 11019.0f, 2.42558118f, 1.76299237f, 0.0136743284f },
+    { 11020.0f, 2.4282026f, 1.78294592f, 0.0113981991f },
+    { 11021.0f, 2.4300892f, 1.81669875f, 0.00910708163f },
+    { 11022.0f, 2.43337205f, 1.83244503f, 0.00683798083f },
+    { 11023.0f, 2.43390133f, 1.95160031f, 0.00445979371f },
+    { 11024.0f, 2.93775729f, 4.71238884f, 1.19919359e-10f },
+    { 11025.0f, 4.59580831f, 1.57079627f, 5.36295678e-11f },
+};
+
+static const TPqfWidebandPoint PqfWidebandTable2[] = {
+    { 1.0f, 16.3808903f, 3.46034708f, 0.00166536607f },
+    { 2.0f, 15.6636444f, 2.99601714f, 0.0046562554f },
+    { 3.0f, 15.6691958f, 3.06922379f, 0.00683819988f },
+    { 4.0f, 15.6220717f, 3.03767809f, 0.00912946724f },
+    { 5.0f, 15.5968846f, 3.02496858f, 0.0113983352f },
+    { 6.0f, 15.5476755f, 2.99982256f, 0.0136805547f },
+    { 7.0f, 15.5019632f, 2.97922512f, 0.0159575897f },
+    { 8.0f, 15.4411872f, 2.9555888f, 0.0182379272f },
+    { 9.0f, 15.3782924f, 2.93329699f, 0.0205167708f },
+    { 10.0f, 15.3038869f, 2.91016516f, 0.0227965437f },
+    { 11.0f, 15.2250398f, 2.88738444f, 0.025075954f },
+    { 12.0f, 15.1364767f, 2.86447273f, 0.0273555306f },
+    { 13.0f, 15.042226f, 2.84157009f, 0.02963514f },
+    { 14.0f, 14.9393025f, 2.81878392f, 0.0319146538f },
+    { 15.0f, 14.8301087f, 2.79589373f, 0.0341943337f },
+    { 20.0f, 14.1742064f, 2.68264051f, 0.0455922582f },
+    { 40.0f, 9.95203287f, 2.25779062f, 0.0911845527f },
+    { 60.0f, 4.06025474f, 2.07021185f, 0.136776822f },
+    { 80.0f, 3.84358473f, 3.69837628f, 0.182369089f },
+    { 100.0f, 9.76001225f, 3.5381211f, 0.227961372f },
+    { 120.0f, 14.0849523f, 3.1171491f, 0.273553646f },
+    { 140.0f, 15.7549109f, 2.66069554f, 0.319145921f },
+    { 160.0f, 14.443986f, 2.20430551f, 0.364738194f },
+    { 180.0f, 10.4558711f, 1.78052053f, 0.410330469f },
+    { 200.0f, 4.77382949f, 1.54922689f, 0.455922743f },
+    { 220.0f, 3.18718556f, 3.03084727f, 0.501515028f },
+    { 240.0f, 8.75901084f, 3.02643749f, 0.547107292f },
+    { 260.0f, 13.0281825f, 2.63275554f, 0.592699567f },
+    { 280.0f, 14.8000731f, 2.1942909f, 0.638291841f },
+    { 300.0f, 13.7557097f, 1.75983293f, 0.683884115f },
+    { 320.0f, 10.2123045f, 1.37456061f, 0.729476387f },
+    { 340.0f, 5.26162279f, 1.2285603f, 0.775068666f },
+    { 360.0f, 3.7236886f, 2.24584312f, 0.820660938f },
+    { 380.0f, 8.27741226f, 2.3935955f, 0.866253209f },
+    { 400.0f, 12.1016365f, 2.06203255f, 0.911845487f },
+    { 420.0f, 13.6863264f, 1.65764361f, 0.957437761f },
+    { 440.0f, 12.6914746f, 1.25398126f, 1.00303004f },
+    { 460.0f, 9.44392761f, 0.914491113f, 1.0486223f },
+    { 480.0f, 5.17788828f, 0.874422996f, 1.09421458f },
+    { 500.0f, 4.55804629f, 1.69076107f, 1.13980686f },
+    { 520.0f, 8.6795827f, 1.78222007f, 1.18539914f },
+    { 540.0f, 12.2630744f, 1.4730505f, 1.23099141f },
+    { 560.0f, 13.8555248f, 1.08348746f, 1.27658368f },
+    { 580.0f, 13.0936721f, 0.686907319f, 1.32217595f },
+    { 600.0f, 10.2253918f, 0.337428385f, 1.36776823f },
+    { 620.0f, 6.18797035f, 0.187024203f, 1.41336051f },
+    { 640.0f, 4.07687536f, 0.774139693f, 1.45895279f },
+    { 660.0f, 7.12857082f, 1.11787244f, 1.50454505f },
+    { 680.0f, 10.6948548f, 0.890221982f, 1.55013733f },
+    { 700.0f, 12.8008208f, 0.535694891f, 1.5957296f },
+    { 720.0f, 12.9912406f, 0.158329421f, 1.64132188f },
+    { 740.0f, 11.3799062f, 6.0880745f, 1.68691415f },
+    { 760.0f, 8.5350239f, 5.82175981f, 1.73250643f },
+    { 780.0f, 5.60044309f, 5.80374035f, 1.7780987f },
+    { 800.0f, 4.76007356f, 6.18984578f, 1.82369097f },
+    { 820.0f, 6.48382321f, 0.0699524431f, 1.86928325f },
+    { 840.0f, 8.40470637f, 6.19814373f, 1.91487552f },
+    { 860.0f, 9.49602639f, 5.94314908f, 1.96046779f },
+    { 880.0f, 9.64687527f, 5.67474444f, 2.00606007f },
+    { 900.0f, 9.08448714f, 5.4282215f, 2.05165235f },
+    { 920.0f, 8.11713622f, 5.21851883f, 2.09724462f },
+    { 940.0f, 6.95622624f, 5.05234437f, 2.14283689f },
+    { 960.0f, 5.69434526f, 4.95181354f, 2.18842917f },
+    { 980.0f, 4.55666092f, 4.9928648f, 2.23402144f },
+    { 1000.0f, 4.30909446f, 5.22449705f, 2.27961372f },
+    { 1020.0f, 5.52861482f, 5.35749743f, 2.32520599f },
+    { 1040.0f, 7.42294717f, 5.22691312f, 2.37079826f },
+    { 1060.0f, 9.00060841f, 4.93758632f, 2.41639054f },
+    { 1080.0f, 9.59823818f, 4.56870562f, 2.46198281f },
+    { 1100.0f, 8.83667609f, 4.15998186f, 2.50757509f },
+    { 1120.0f, 6.63324228f, 3.74059775f, 2.55316736f },
+    { 1140.0f, 3.23375881f, 3.39029263f, 2.59875964f },
+    { 1160.0f, 1.26080117f, 5.20050711f, 2.64435191f },
+    { 1180.0f, 5.29660366f, 5.18732718f, 2.68994418f },
+    { 1200.0f, 8.78282005f, 4.73914947f, 2.73553646f },
+    { 1220.0f, 10.894512f, 4.24370765f, 2.78112873f },
+    { 1240.0f, 11.167807f, 3.72459042f, 2.82672101f },
+    { 1260.0f, 9.47585333f, 3.17813522f, 2.87231328f },
+    { 1280.0f, 6.08786895f, 2.56380882f, 2.91790556f },
+    { 1300.0f, 1.97754795f, 1.41807119f, 2.96349783f },
+    { 1320.0f, 3.9824746f, 5.28920403f, 3.00909011f },
+    { 1340.0f, 8.19466983f, 4.54918593f, 3.05468238f },
+    { 1360.0f, 11.0931197f, 3.9547633f, 3.10027469f },
+    { 1363.125f, 11.3765862f, 3.86497782f, 3.10739834f },
+    { 1364.125f, 11.456359f, 3.83610014f, 3.10967816f },
+    { 1365.125f, 11.5312513f, 3.80765596f, 3.11195751f },
+    { 1366.125f, 11.6002031f, 3.77878504f, 3.11423738f },
+    { 1367.125f, 11.6647216f, 3.75045509f, 3.11651667f },
+    { 1368.125f, 11.7224687f, 3.7216152f, 3.11879655f },
+    { 1369.125f, 11.7769237f, 3.69335512f, 3.12107579f },
+    { 1370.125f, 11.8228658f, 3.66469591f, 3.12335553f },
+    { 1371.125f, 11.868149f, 3.63637679f, 3.12563489f },
+    { 1372.125f, 11.9009738f, 3.60857908f, 3.12791377f },
+    { 1373.125f, 11.9406031f, 3.57954247f, 3.13019406f },
+    { 1374.125f, 11.9558949f, 3.55682594f, 3.13246783f },
+    { 1375.125f, 12.0126094f, 3.52198657f, 3.1347556f },
+    { 1376.125f, 12.0046937f, 3.94822597f, 3.13475519f },
+    { 1377.125f, 11.9967779f, 4.37446537f, 3.13475479f },
+    { 1378.125f, 11.9888621f, 4.80070477f, 3.13475439f },
+    { 1379.125f, 11.9809463f, 5.22694417f, 3.13475398f },
+    { 1380.0f, 11.97402f, 5.59990365f, 3.13475363f },
+    { 1380.125f, 11.9730306f, 5.65318357f, 3.13475358f },
+    { 1381.125f, 11.9651148f, 6.07942297f, 3.13475318f },
+    { 1382.125f, 11.9543323f, 6.11573927f, 3.13246257f },
+    { 1383.125f, 11.9315256f, 6.13336894f, 3.13019463f },
+    { 1384.125f, 11.8996348f, 6.16488856f, 3.1279116f },
+    { 1385.125f, 11.8648799f, 6.19059746f, 3.12563529f },
+    { 1386.125f, 11.8213527f, 6.22051666f, 3.12335441f },
+    { 1387.125f, 11.774761f, 6.24828891f, 3.12107601f },
+    { 1388.125f, 11.7203787f, 6.27766433f, 3.11879591f },
+    { 1389.125f, 11.6622109f, 0.023049085f, 3.11651678f },
+    { 1390.125f, 11.5970492f, 0.0522707963f, 3.114237f },
+    { 1391.125f, 11.5275985f, 0.0812520863f, 3.11195755f },
+    { 1392.125f, 11.451718f, 0.110483045f, 3.10967792f },
+    { 1393.125f, 11.3712043f, 0.139732265f, 3.10739834f },
+    { 1400.0f, 10.671806f, 0.343433728f, 3.0917261f },
+    { 1420.0f, 7.387276f, 0.987330626f, 3.04613383f },
+    { 1440.0f, 3.1412399f, 2.00608147f, 3.00054156f },
+    { 1460.0f, 3.78098928f, 4.29397585f, 2.9549493f },
+    { 1480.0f, 8.15350467f, 5.19111031f, 2.90935701f },
+    { 1500.0f, 11.3493576f, 5.82828863f, 2.86376473f },
+    { 1520.0f, 12.4421159f, 0.142389009f, 2.81817246f },
+    { 1540.0f, 11.1576291f, 0.749770409f, 2.77258018f },
+    { 1560.0f, 7.79791151f, 1.43318018f, 2.72698791f },
+    { 1580.0f, 3.6689249f, 2.54895385f, 2.68139563f },
+    { 1600.0f, 4.60601935f, 4.5776289f, 2.63580336f },
+    { 1620.0f, 9.00217871f, 5.50578684f, 2.59021109f },
+    { 1640.0f, 12.1956293f, 6.16997933f, 2.54461881f },
+    { 1660.0f, 13.1229573f, 0.508630418f, 2.49902654f },
+    { 1680.0f, 11.5272003f, 1.15312886f, 2.45343426f },
+    { 1700.0f, 7.90701084f, 1.9252325f, 2.40784199f },
+    { 1720.0f, 4.53821904f, 3.26839789f, 2.36224971f },
+    { 1740.0f, 6.87215096f, 4.88230733f, 2.31665744f },
+    { 1760.0f, 11.3272389f, 5.75063971f, 2.27106517f },
+    { 1780.0f, 14.2245324f, 0.140421053f, 2.22547289f },
+    { 1800.0f, 14.4146367f, 0.779420689f, 2.17988062f },
+    { 1820.0f, 11.6822145f, 1.46489269f, 2.13428834f },
+    { 1840.0f, 7.03035205f, 2.41284417f, 2.08869608f },
+    { 1860.0f, 6.03845565f, 4.19284239f, 2.04310379f },
+    { 1880.0f, 12.0104738f, 5.3544479f, 1.99751152f },
+    { 1900.0f, 18.0854276f, 6.0683705f, 1.95191925f },
+    { 1920.0f, 21.5726785f, 0.402597589f, 1.90632697f },
+    { 1940.0f, 21.2120168f, 1.00133791f, 1.8607347f },
+    { 1960.0f, 16.632189f, 1.63342975f, 1.81514242f },
+    { 1980.0f, 8.7570793f, 2.49064605f, 1.76955015f },
+    { 2000.0f, 6.65424812f, 4.67696888f, 1.72395787f },
+    { 2020.0f, 17.1910945f, 5.78430641f, 1.6783656f },
+    { 2040.0f, 27.477392f, 0.151723658f, 1.63277332f },
+    { 2060.0f, 34.1387287f, 0.730234131f, 1.58718105f },
+    { 2080.0f, 35.2587945f, 1.29191355f, 1.54158878f },
+    { 2100.0f, 29.905588f, 1.86313239f, 1.4959965f },
+    { 2120.0f, 18.4324086f, 2.50613732f, 1.45040423f },
+    { 2140.0f, 5.21427749f, 4.11299605f, 1.40481195f },
+    { 2160.0f, 18.4735171f, 6.14191845f, 1.35921968f },
+    { 2180.0f, 35.7576351f, 0.520856129f, 1.3136274f },
+    { 2200.0f, 48.3094065f, 1.08694311f, 1.26803513f },
+    { 2220.0f, 52.5127119f, 1.63331159f, 1.22244286f },
+    { 2240.0f, 45.9793327f, 2.18298363f, 1.17685058f },
+    { 2260.0f, 28.2001607f, 2.78098007f, 1.13125831f },
+    { 2280.0f, 5.19730453f, 4.66033862f, 1.08566603f },
+    { 2300.0f, 32.8296281f, 0.333976605f, 1.04007376f },
+    { 2320.0f, 62.4339922f, 0.92713595f, 0.994481483f },
+    { 2340.0f, 78.5759951f, 1.46494676f, 0.94888921f },
+    { 2360.0f, 67.3671648f, 1.99144831f, 0.903296935f },
+    { 2380.0f, 12.5239695f, 2.59122162f, 0.857704661f },
+    { 2400.0f, 104.407088f, 6.12952336f, 0.812112387f },
+    { 2420.0f, 302.735478f, 0.36364863f, 0.766520112f },
+    { 2440.0f, 602.492056f, 0.873219286f, 0.720927838f },
+    { 2460.0f, 1023.1576f, 1.38025597f, 0.675335564f },
+    { 2480.0f, 1582.79288f, 1.88588318f, 0.629743289f },
+    { 2500.0f, 2297.03168f, 2.39057444f, 0.584151015f },
+    { 2520.0f, 3178.05055f, 2.89460245f, 0.538558741f },
+    { 2540.0f, 4233.55141f, 3.39815431f, 0.492966466f },
+    { 2560.0f, 5465.8075f, 3.90136978f, 0.447374192f },
+    { 2580.0f, 6870.8535f, 4.40435787f, 0.401781918f },
+    { 2600.0f, 8437.90592f, 4.90720455f, 0.356189643f },
+    { 2620.0f, 10149.1178f, 5.40997597f, 0.310597369f },
+    { 2640.0f, 11979.7514f, 5.91272227f, 0.265005095f },
+    { 2660.0f, 13898.8413f, 0.132291651f, 0.219412821f },
+    { 2680.0f, 15870.3588f, 0.635079696f, 0.173820545f },
+    { 2700.0f, 17854.8498f, 1.13790856f, 0.128228272f },
+    { 2720.0f, 19811.4901f, 1.6407969f, 0.0826359844f },
+    { 2740.0f, 21700.1912f, 2.14370869f, 0.0370437238f },
+    { 2741.25f, 21815.3546f, 2.17508706f, 0.0341942701f },
+    { 2742.25f, 21907.1334f, 2.20045172f, 0.0319144128f },
+    { 2743.25f, 21998.6429f, 2.22533963f, 0.0296350913f },
+    { 2744.25f, 22089.6568f, 2.25081549f, 0.0273551084f },
+    { 2745.25f, 22181.1279f, 2.27557059f, 0.0250759373f },
+    { 2746.25f, 22271.0545f, 2.30120548f, 0.0227957728f },
+    { 2747.25f, 22363.2044f, 2.32576555f, 0.0205168232f },
+    { 2748.25f, 22451.2729f, 2.35161913f, 0.0182364023f },
+    { 2749.25f, 22546.213f, 2.37590665f, 0.015957765f },
+    { 2750.25f, 22630.2002f, 2.40197445f, 0.0136770589f },
+    { 2751.25f, 22736.1503f, 2.42606749f, 0.0113986622f },
+    { 2752.25f, 22807.3915f, 2.45138649f, 0.00911853478f },
+    { 2753.25f, 22981.3073f, 2.47881895f, 0.00683659113f },
+    { 2754.25f, 22978.8866f, 2.48011396f, 0.00457973515f },
+    { 2755.25f, 23053.3713f, 2.08600029f, 0.00503192522f },
+    { 2756.25f, 23127.856f, 1.69188663f, 0.00548411529f },
+    { 2757.25f, 23202.3407f, 1.29777296f, 0.00593630536f },
+    { 2758.25f, 23276.8254f, 0.903659292f, 0.00638849543f },
+    { 2759.25f, 23351.3101f, 0.509545625f, 0.0068406855f },
+    { 2760.0f, 23443.351f, 0.488919467f, 0.00855379506f },
+    { 2760.25f, 23501.0031f, 0.480366984f, 0.00912674199f },
+    { 2761.25f, 23579.7068f, 0.463310448f, 0.0113976824f },
+    { 2762.25f, 23674.3744f, 0.435576446f, 0.0136804679f },
+    { 2763.25f, 23758.7409f, 0.41321424f, 0.0159570596f },
+    { 2764.25f, 23845.0626f, 0.386797214f, 0.0182381712f },
+    { 2765.25f, 23930.02f, 0.362901722f, 0.02051642f },
+    { 2766.25f, 24013.898f, 0.337098752f, 0.0227967962f },
+    { 2767.25f, 24098.3606f, 0.312580632f, 0.0250757228f },
+    { 2768.25f, 24181.0915f, 0.287087919f, 0.0273557354f },
+    { 2769.25f, 24264.7638f, 0.262268445f, 0.0296349911f },
+    { 2770.25f, 24346.7056f, 0.236944357f, 0.0319148083f },
+    { 2771.25f, 24429.5012f, 0.211964099f, 0.0341942399f },
+    { 2780.0f, 25131.659f, 6.27512496f, 0.054140848f },
+    { 2800.0f, 26617.8424f, 5.77215851f, 0.0997331043f },
+    { 2820.0f, 27926.3715f, 5.2691711f, 0.145325373f },
+    { 2840.0f, 29049.2092f, 4.76617981f, 0.190917649f },
+    { 2860.0f, 29986.9553f, 4.26319902f, 0.236509923f },
+    { 2880.0f, 30747.8343f, 3.76022905f, 0.282102198f },
+    { 2900.0f, 31346.382f, 3.25727223f, 0.327694472f },
+    { 2920.0f, 31801.7081f, 2.7543265f, 0.373286746f },
+    { 2940.0f, 32135.6045f, 2.25139052f, 0.41887902f },
+    { 2960.0f, 32370.6955f, 1.7484617f, 0.464471295f },
+    { 2980.0f, 32528.8118f, 1.24553847f, 0.510063569f },
+    { 3000.0f, 32629.7125f, 0.742619494f, 0.555655843f },
+    { 3020.0f, 32690.2412f, 0.239704052f, 0.601248118f },
+    { 3040.0f, 32723.9232f, 6.01997666f, 0.646840392f },
+    { 3060.0f, 32740.9569f, 5.51706549f, 0.692432666f },
+    { 3080.0f, 32748.5201f, 5.0141529f, 0.738024941f },
+    { 3100.0f, 32751.2724f, 4.51123575f, 0.783617215f },
+    { 3120.0f, 32751.9527f, 4.0083096f, 0.82920949f },
+    { 3140.0f, 32751.9684f, 3.50537061f, 0.874801764f },
+    { 3160.0f, 32751.9018f, 3.00241534f, 0.920394038f },
+    { 3180.0f, 32751.9038f, 2.49944327f, 0.965986313f },
+    { 3200.0f, 32751.9494f, 1.99645705f, 1.01157859f },
+    { 3220.0f, 32751.9868f, 1.49346228f, 1.05717086f },
+    { 3240.0f, 32751.9912f, 0.990466689f, 1.10276314f },
+    { 3260.0f, 32751.9706f, 0.487480635f, 1.14835541f },
+    { 3280.0f, 32751.9486f, 6.26769817f, 1.19394768f },
+    { 3300.0f, 32751.9422f, 5.76475551f, 1.23953996f },
+    { 3320.0f, 32751.9547f, 5.26184056f, 1.28513223f },
+    { 3340.0f, 32751.9757f, 4.75895102f, 1.33072451f },
+    { 3360.0f, 32751.991f, 4.25608006f, 1.37631678f },
+    { 3380.0f, 32751.992f, 3.75321664f, 1.42190906f },
+    { 3400.0f, 32751.9792f, 3.25034774f, 1.46750133f },
+    { 3420.0f, 32751.9619f, 2.74746124f, 1.5130936f },
+    { 3440.0f, 32751.9519f, 2.24454774f, 1.55868588f },
+    { 3460.0f, 32751.9553f, 1.74160267f, 1.60427815f },
+    { 3480.0f, 32751.9699f, 1.23862696f, 1.64987043f },
+    { 3500.0f, 32751.9865f, 0.735628053f, 1.6954627f },
+    { 3520.0f, 32751.9937f, 0.232616208f, 1.74105498f },
+    { 3540.0f, 32751.9854f, 6.01279035f, 1.78664725f },
+    { 3560.0f, 32751.9656f, 5.50979147f, 1.83223953f },
+    { 3580.0f, 32751.9468f, 5.00681572f, 1.8778318f },
+    { 3600.0f, 32751.9421f, 4.50386723f, 1.92342407f },
+    { 3620.0f, 32751.9576f, 4.00094545f, 1.96901635f },
+    { 3640.0f, 32751.9814f, 3.49804533f, 2.01460862f },
+    { 3660.0f, 32751.993f, 2.99515715f, 2.0602009f },
+    { 3680.0f, 32751.9727f, 2.49227012f, 2.10579317f },
+    { 3700.0f, 32751.9261f, 1.98937404f, 2.15138545f },
+    { 3720.0f, 32751.894f, 1.48646074f, 2.19697772f },
+    { 3740.0f, 32751.9272f, 0.983527134f, 2.24256999f },
+    { 3760.0f, 32751.9927f, 0.480573856f, 2.28816227f },
+    { 3780.0f, 32751.7781f, 6.26079129f, 2.33375454f },
+    { 3800.0f, 32750.3692f, 5.75781571f, 2.37934682f },
+    { 3820.0f, 32745.806f, 5.25484152f, 2.42493909f },
+    { 3840.0f, 32734.5238f, 4.75187616f, 2.47053137f },
+    { 3860.0f, 32710.7543f, 4.24892454f, 2.51612364f },
+    { 3880.0f, 32665.9565f, 3.74598842f, 2.56171591f },
+    { 3900.0f, 32588.3944f, 3.24306638f, 2.60730819f },
+    { 3920.0f, 32462.9628f, 2.74015379f, 2.65290046f },
+    { 3940.0f, 32271.375f, 2.2372445f, 2.69849274f },
+    { 3960.0f, 31992.77f, 1.73433182f, 2.74408501f },
+    { 3980.0f, 31604.7618f, 1.23141075f, 2.78967729f },
+    { 4000.0f, 31084.8969f, 0.728477157f, 2.83526956f },
+    { 4020.0f, 30412.3986f, 0.225529979f, 2.88086183f },
+    { 4040.0f, 29570.0774f, 6.00575511f, 2.92645411f },
+    { 4060.0f, 28546.1423f, 5.50278467f, 2.97204638f },
+    { 4080.0f, 27335.8364f, 4.99980863f, 3.01763866f },
+    { 4100.0f, 25942.4637f, 4.49682098f, 3.06323095f },
+    { 4119.375f, 24429.7143f, 4.00965628f, 3.10739836f },
+    { 4120.0f, 24378.6537f, 3.99393651f, 3.10882312f },
+    { 4120.375f, 24347.5737f, 3.9842986f, 3.10967821f },
+    { 4121.375f, 24265.3989f, 3.95940672f, 3.11195754f },
+    { 4122.375f, 24182.1901f, 3.93396278f, 3.11423749f },
+    { 4123.375f, 24099.92f, 3.90918087f, 3.11651669f },
+    { 4124.375f, 24015.2939f, 3.88363387f, 3.11879676f },
+    { 4125.375f, 23933.7428f, 3.85899558f, 3.12107581f },
+    { 4126.375f, 23846.8606f, 3.83336371f, 3.12335599f },
+    { 4127.375f, 23768.2723f, 3.80887646f, 3.12563487f },
+    { 4128.375f, 23676.7535f, 3.78341675f, 3.12791493f },
+    { 4129.375f, 23609.4436f, 3.75879489f, 3.13019399f },
+    { 4130.375f, 23504.255f, 3.73568293f, 3.13247181f },
+    { 4131.375f, 23503.4635f, 3.7067018f, 3.13475598f },
+    { 4132.375f, 23324.2864f, 3.72381413f, 3.13699385f },
+    { 4133.375f, 23227.6465f, 4.15350946f, 3.13654554f },
+    { 4134.375f, 23131.0066f, 4.58320479f, 3.13609723f },
+    { 4135.375f, 23034.3667f, 5.01290012f, 3.13564892f },
+    { 4136.375f, 22937.7268f, 5.44259544f, 3.13520061f },
+    { 4137.375f, 22841.087f, 5.87229077f, 3.1347523f },
+    { 4138.375f, 22802.1905f, 5.90285199f, 3.13246443f },
+    { 4139.375f, 22710.3262f, 5.91853f, 3.13019487f },
+    { 4140.0f, 22660.3902f, 5.93400531f, 3.12877016f },
+    { 4140.375f, 22627.1118f, 5.94642566f, 3.12791187f },
+    { 4141.375f, 22538.4942f, 5.96855018f, 3.12563551f },
+    { 4142.375f, 22449.1953f, 5.99495171f, 3.1233544f },
+    { 4143.375f, 22360.4504f, 6.01882021f, 3.12107617f },
+    { 4144.375f, 22269.5682f, 6.04457435f, 3.11879584f },
+    { 4145.375f, 22180.1219f, 6.06911507f, 3.11651688f },
+    { 4146.375f, 22088.5612f, 6.09455834f, 3.11423692f },
+    { 4147.375f, 21998.332f, 6.11940916f, 3.11195763f },
+    { 4148.375f, 21906.316f, 6.14469094f, 3.10967786f },
+    { 4149.375f, 21815.3307f, 6.16969999f, 3.10739839f },
+    { 4160.0f, 20825.7746f, 0.153662522f, 3.08317751f },
+    { 4180.0f, 18900.3754f, 0.656537345f, 3.03758528f },
+    { 4200.0f, 16925.6013f, 1.15943797f, 2.991993f },
+    { 4220.0f, 14942.1311f, 1.66231565f, 2.94640073f },
+    { 4240.0f, 12990.4425f, 2.16517767f, 2.90080845f },
+    { 4260.0f, 11108.6048f, 2.66802864f, 2.85521618f },
+    { 4280.0f, 9330.45303f, 3.1708798f, 2.80962391f },
+    { 4300.0f, 7684.1459f, 3.67374847f, 2.76403163f },
+    { 4320.0f, 6191.24391f, 4.17665866f, 2.71843936f },
+    { 4340.0f, 4866.27685f, 4.67964591f, 2.67284708f },
+    { 4360.0f, 3716.7787f, 5.18275993f, 2.62725481f },
+    { 4380.0f, 2743.70088f, 5.68607097f, 2.58166253f },
+    { 4400.0f, 1942.11258f, 6.18968473f, 2.53607026f },
+    { 4420.0f, 1302.08984f, 0.410581398f, 2.49047799f },
+    { 4440.0f, 809.707575f, 0.915423459f, 2.44488571f },
+    { 4460.0f, 448.069388f, 1.42166299f, 2.39929344f },
+    { 4480.0f, 198.32972f, 1.93138404f, 2.35370116f },
+    { 4500.0f, 40.6908179f, 2.46587637f, 2.30810889f },
+    { 4520.0f, 44.775996f, 6.05149769f, 2.26251661f },
+    { 4540.0f, 76.9762392f, 0.294867059f, 2.21692434f },
+    { 4560.0f, 73.4110497f, 0.81587374f, 2.17133207f },
+    { 4580.0f, 49.2854039f, 1.35234137f, 2.12573979f },
+    { 4600.0f, 17.2199049f, 1.99906637f, 2.08014752f },
+    { 4620.0f, 14.6084752f, 5.20339886f, 2.03455524f },
+    { 4640.0f, 37.8289189f, 5.86960261f, 1.98896297f },
+    { 4660.0f, 50.475001f, 0.130297124f, 1.94337069f },
+    { 4680.0f, 51.7583519f, 0.66142521f, 1.89777842f },
+    { 4700.0f, 43.1847988f, 1.19681815f, 1.85218615f },
+    { 4720.0f, 27.7458744f, 1.75846876f, 1.80659387f },
+    { 4740.0f, 9.40197293f, 2.5137038f, 1.7610016f },
+    { 4760.0f, 9.98705657f, 5.48842133f, 1.71540932f },
+    { 4780.0f, 24.3144299f, 6.20950306f, 1.66981705f },
+    { 4800.0f, 33.190957f, 0.490828556f, 1.62422477f },
+    { 4820.0f, 35.5079564f, 1.03556902f, 1.5786325f },
+    { 4840.0f, 31.5868518f, 1.58255668f, 1.53304023f },
+    { 4860.0f, 22.8205077f, 2.15220217f, 1.48744795f },
+    { 4880.0f, 11.4061343f, 2.82685683f, 1.44185567f },
+    { 4900.0f, 3.47836446f, 4.99336107f, 1.3962634f },
+    { 4920.0f, 12.1097829f, 0.185441748f, 1.35067113f },
+    { 4940.0f, 19.0386571f, 0.826642906f, 1.30507885f },
+    { 4960.0f, 21.8393099f, 1.40369603f, 1.25948658f },
+    { 4980.0f, 20.3843138f, 1.97654067f, 1.2138943f },
+    { 5000.0f, 15.4235377f, 2.57964014f, 1.16830203f },
+    { 5020.0f, 8.45609694f, 3.32053769f, 1.12270975f },
+    { 5040.0f, 3.55460991f, 5.08577009f, 1.07711748f },
+    { 5060.0f, 8.15626862f, 0.382057476f, 1.03152521f },
+    { 5080.0f, 12.6587253f, 1.10217519f, 0.985932934f },
+    { 5100.0f, 14.4031828f, 1.71323609f, 0.940340658f },
+    { 5120.0f, 13.1204963f, 2.31296371f, 0.894748386f },
+    { 5140.0f, 9.32285241f, 2.9626309f, 0.849156111f },
+    { 5160.0f, 4.3752934f, 3.92017056f, 0.803563836f },
+    { 5180.0f, 4.02311215f, 6.05732423f, 0.757971561f },
+    { 5200.0f, 8.46878314f, 0.777285524f, 0.712379287f },
+    { 5220.0f, 11.641222f, 1.42547107f, 0.666787012f },
+    { 5240.0f, 12.4540568f, 2.01058149f, 0.621194733f },
+    { 5260.0f, 10.7539424f, 2.58788534f, 0.575602466f },
+    { 5280.0f, 6.97419985f, 3.20938172f, 0.530010189f },
+    { 5300.0f, 2.28706326f, 4.27849499f, 0.484417915f },
+    { 5320.0f, 4.05764705f, 0.493914918f, 0.43882564f },
+    { 5340.0f, 8.41511385f, 1.2317576f, 0.393233366f },
+    { 5360.0f, 11.169367f, 1.80664329f, 0.347641087f },
+    { 5380.0f, 11.6933337f, 2.34867671f, 0.302048814f },
+    { 5400.0f, 9.90651237f, 2.88206265f, 0.256456544f },
+    { 5420.0f, 6.2000535f, 3.42542211f, 0.210864276f },
+    { 5440.0f, 1.37335402f, 4.17371007f, 0.165271987f },
+    { 5460.0f, 3.77592124f, 1.13622075f, 0.119679717f },
+    { 5480.0f, 8.03561208f, 1.70277786f, 0.0740874371f },
+    { 5497.5f, 10.4749307f, 2.15970941f, 0.0341942668f },
+    { 5498.5f, 10.5690624f, 2.18571871f, 0.0319144049f },
+    { 5499.5f, 10.6579603f, 2.21121311f, 0.0296350935f },
+    { 5500.0f, 10.7006455f, 2.22427617f, 0.0284950751f },
+    { 5500.5f, 10.7414683f, 2.23729393f, 0.027355101f },
+    { 5501.5f, 10.8199895f, 2.26262285f, 0.0250759289f },
+    { 5502.5f, 10.8926176f, 2.28881269f, 0.0227957622f },
+    { 5503.5f, 10.9610647f, 2.31390163f, 0.0205168201f },
+    { 5504.5f, 11.0223129f, 2.34029204f, 0.0182363755f },
+    { 5505.5f, 11.0815464f, 2.36505489f, 0.0159577625f },
+    { 5506.5f, 11.1302302f, 2.3916692f, 0.0136769878f },
+    { 5507.5f, 11.1842768f, 2.41616544f, 0.0113986636f },
+    { 5508.5f, 11.2160416f, 2.44214466f, 0.00911831378f },
+    { 5509.5f, 11.2928906f, 2.46985572f, 0.00683658836f },
+    { 5510.5f, 11.2778294f, 2.47325536f, 0.00457799273f },
+    { 5511.5f, 11.2843381f, 2.08186022f, 0.00503053563f },
+    { 5512.5f, 11.2908469f, 1.69046509f, 0.00548307853f },
+    { 5513.5f, 11.2973556f, 1.29906996f, 0.00593562143f },
+    { 5514.5f, 11.3038643f, 0.907674822f, 0.00638816433f },
+    { 5515.5f, 11.3103731f, 0.516279689f, 0.00684070723f },
+    { 5516.5f, 11.3377258f, 0.486855385f, 0.00912663208f },
+    { 5517.5f, 11.324893f, 0.469360495f, 0.01139768f },
+    { 5518.5f, 11.3145963f, 0.441318328f, 0.0136804454f },
+    { 5519.5f, 11.2939025f, 0.418629075f, 0.0159570538f },
+    { 5520.0f, 11.2835553f, 0.405314249f, 0.0170975744f },
+    { 5520.5f, 11.2689213f, 0.391910561f, 0.0182381663f },
+    { 5521.5f, 11.2379599f, 0.367719353f, 0.0205164169f },
+    { 5522.5f, 11.2012684f, 0.341631714f, 0.0227967975f },
+    { 5523.5f, 11.1595466f, 0.316840786f, 0.0250757231f },
+    { 5524.5f, 11.1118852f, 0.291079995f, 0.0273557385f },
+    { 5525.5f, 11.0594836f, 0.266010757f, 0.0296349895f },
+    { 5526.5f, 11.0011006f, 0.24043629f, 0.0319148093f },
+    { 5527.5f, 10.9380099f, 0.215218379f, 0.0341942387f },
+    { 5540.0f, 9.71840167f, 6.18170389f, 0.0626894017f },
+    { 5560.0f, 6.35448725f, 5.67718983f, 0.108281652f },
+    { 5580.0f, 1.87486193f, 5.18165681f, 0.153873926f },
+    { 5600.0f, 2.84544568f, 1.51224874f, 0.199466199f },
+    { 5620.0f, 6.91265795f, 1.01161419f, 0.245058475f },
+    { 5640.0f, 9.58885043f, 0.504846917f, 0.290650748f },
+    { 5660.0f, 10.4260573f, 6.27673635f, 0.336243023f },
+    { 5680.0f, 9.34149761f, 5.75719109f, 0.381835295f },
+    { 5700.0f, 6.62046482f, 5.21644968f, 0.427427572f },
+    { 5720.0f, 2.86741441f, 4.57006623f, 0.473019854f },
+    { 5740.0f, 1.48479438f, 1.61119069f, 0.518612121f },
+    { 5760.0f, 5.03792758f, 0.756495792f, 0.564204395f },
+    { 5780.0f, 7.59921404f, 0.179288488f, 0.609796671f },
+    { 5800.0f, 8.68651037f, 5.90183213f, 0.655388944f },
+    { 5820.0f, 8.21045794f, 5.323858f, 0.700981218f },
+    { 5840.0f, 6.41797366f, 4.68961766f, 0.746573495f },
+    { 5860.0f, 3.92787248f, 3.87111139f, 0.792165764f },
+    { 5880.0f, 2.38782531f, 2.37612517f, 0.837758041f },
+    { 5900.0f, 3.80924414f, 0.942131264f, 0.883350315f },
+    { 5920.0f, 5.63277791f, 0.113696812f, 0.928942597f },
+    { 5940.0f, 6.6065383f, 5.70049838f, 0.974534864f },
+    { 5960.0f, 6.5566251f, 5.00565421f, 1.02012713f },
+    { 5980.0f, 5.71932001f, 4.24129745f, 1.06571941f },
+    { 6000.0f, 4.68129944f, 3.32655689f, 1.11131169f },
+    { 6020.0f, 4.25987391f, 2.24649831f, 1.15690396f },
+    { 6040.0f, 4.7160572f, 1.20594056f, 1.20249624f },
+    { 6060.0f, 5.3886247f, 0.320423791f, 1.24808851f },
+    { 6080.0f, 5.69347602f, 5.80109973f, 1.29368079f },
+    { 6100.0f, 5.48930151f, 4.9996343f, 1.33927306f },
+    { 6120.0f, 4.9814134f, 4.13630081f, 1.38486533f },
+    { 6140.0f, 4.58380923f, 3.18255686f, 1.43045761f },
+    { 6160.0f, 4.61167737f, 2.19573479f, 1.47604988f },
+    { 6180.0f, 4.94819446f, 1.26770118f, 1.52164216f },
+    { 6200.0f, 5.24613192f, 0.408856026f, 1.56723443f },
+    { 6220.0f, 5.30777627f, 5.85926561f, 1.61282671f },
+    { 6240.0f, 5.17439481f, 5.01219687f, 1.65841898f },
+    { 6260.0f, 5.02149151f, 4.13872922f, 1.70401125f },
+    { 6280.0f, 4.95661666f, 3.26288429f, 1.74960352f },
+    { 6300.0f, 4.87896696f, 2.41398107f, 1.7951958f },
+    { 6320.0f, 4.57852351f, 1.58367186f, 1.84078808f },
+    { 6340.0f, 3.97194102f, 0.711698256f, 1.88638036f },
+    { 6360.0f, 3.34212339f, 5.96978215f, 1.93197262f },
+    { 6380.0f, 3.42464916f, 4.79156474f, 1.9775649f },
+    { 6400.0f, 4.45040912f, 3.7694464f, 2.02315717f },
+    { 6420.0f, 5.68725505f, 2.97511845f, 2.06874945f },
+    { 6440.0f, 6.44578817f, 2.30349014f, 2.11434172f },
+    { 6460.0f, 6.31693242f, 1.68658875f, 2.15993399f },
+    { 6480.0f, 5.13831238f, 1.07961127f, 2.20552627f },
+    { 6500.0f, 3.01526775f, 0.393172155f, 2.25111855f },
+    { 6520.0f, 1.00384364f, 4.85779465f, 2.29671083f },
+    { 6540.0f, 3.35420967f, 3.13194814f, 2.34230309f },
+    { 6560.0f, 6.10057441f, 2.48230425f, 2.38789537f },
+    { 6580.0f, 8.01678662f, 1.93377775f, 2.43348764f },
+    { 6600.0f, 8.63282109f, 1.41384491f, 2.47907992f },
+    { 6620.0f, 7.72468177f, 0.905818014f, 2.52467219f },
+    { 6640.0f, 5.3514889f, 0.402022785f, 2.57026447f },
+    { 6660.0f, 1.86265872f, 6.16665663f, 2.61585674f },
+    { 6680.0f, 2.15463666f, 2.59592975f, 2.66144901f },
+    { 6700.0f, 5.96223634f, 2.08459893f, 2.70704129f },
+    { 6720.0f, 8.82354441f, 1.58945324f, 2.75263356f },
+    { 6740.0f, 10.1384919f, 1.09685993f, 2.79822584f },
+    { 6760.0f, 9.57531531f, 0.604871611f, 2.84381812f },
+    { 6780.0f, 7.15341447f, 0.112582039f, 2.88941039f },
+    { 6800.0f, 3.25980463f, 5.90128948f, 2.93500266f },
+    { 6820.0f, 1.40865657f, 2.28210638f, 2.98059495f },
+    { 6840.0f, 5.96767952f, 1.78090459f, 3.02618721f },
+    { 6860.0f, 9.51633691f, 1.28598939f, 3.07177948f },
+    { 6875.625f, 11.099141f, 0.899233501f, 3.10739837f },
+    { 6876.625f, 11.1579093f, 0.874245472f, 3.10967822f },
+    { 6877.625f, 11.2113894f, 0.849740071f, 3.11195754f },
+    { 6878.625f, 11.2592038f, 0.824651825f, 3.11423751f },
+    { 6879.625f, 11.302101f, 0.800244674f, 3.1165167f },
+    { 6880.0f, 11.316348f, 0.790500708f, 3.11737207f },
+    { 6880.625f, 11.3386497f, 0.775035093f, 3.11879681f },
+    { 6881.625f, 11.3711681f, 0.750795656f, 3.12107581f },
+    { 6882.625f, 11.3959878f, 0.725452653f, 3.12335608f },
+    { 6883.625f, 11.4191472f, 0.701397288f, 3.12563488f },
+    { 6884.625f, 11.4308826f, 0.676083986f, 3.12791516f },
+    { 6885.625f, 11.4487206f, 0.651999064f, 3.13019399f },
+    { 6886.625f, 11.4429504f, 0.628465813f, 3.13247263f },
+    { 6887.625f, 11.483066f, 0.600380167f, 3.13475601f },
+    { 6888.625f, 11.4297452f, 0.611330319f, 3.13700061f },
+    { 6889.625f, 11.3998758f, 1.02766751f, 3.13655092f },
+    { 6890.625f, 11.3700063f, 1.4440047f, 3.13610123f },
+    { 6891.625f, 11.3401369f, 1.86034189f, 3.13565154f },
+    { 6892.625f, 11.3102674f, 2.27667908f, 3.13520186f },
+    { 6893.625f, 11.2803979f, 2.69301627f, 3.13475217f },
+    { 6894.625f, 11.2657269f, 2.72273293f, 3.13246496f },
+    { 6895.625f, 11.2161749f, 2.73856035f, 3.13019492f },
+    { 6896.625f, 11.1667714f, 2.76608624f, 3.12791197f },
+    { 6897.625f, 11.1083702f, 2.78795918f, 3.12563554f },
+    { 6898.625f, 11.0446936f, 2.81404552f, 3.12335443f },
+    { 6899.625f, 10.9755859f, 2.83760408f, 3.12107619f },
+    { 6900.0f, 10.9479625f, 2.84769493f, 3.12022045f },
+    { 6900.625f, 10.9002293f, 2.86305919f, 3.11879584f },
+    { 6901.625f, 10.820078f, 2.88726987f, 3.11651691f },
+    { 6902.625f, 10.7336787f, 2.91241922f, 3.11423692f },
+    { 6903.625f, 10.6425249f, 2.93695727f, 3.11195763f },
+    { 6904.625f, 10.5453065f, 2.96194695f, 3.10967784f },
+    { 6905.625f, 10.4433371f, 2.98663901f, 3.1073984f },
+    { 6920.0f, 8.41203973f, 3.34410339f, 3.07462901f },
+    { 6940.0f, 4.13967814f, 3.84379131f, 3.02903671f },
+    { 6960.0f, 1.07492995f, 1.18306564f, 2.98344447f },
+    { 6980.0f, 6.22502295f, 1.69501445f, 2.93785217f },
+    { 7000.0f, 10.2899892f, 2.19753435f, 2.8922599f },
+    { 7020.0f, 12.4410529f, 2.70126124f, 2.84666763f },
+    { 7040.0f, 12.2149737f, 3.20754501f, 2.80107536f },
+    { 7060.0f, 9.61652817f, 3.71935399f, 2.75548307f },
+    { 7080.0f, 5.12847803f, 4.25151793f, 2.70989081f },
+    { 7100.0f, 5.49389065f, 3.13481826f, 2.66429854f },
+    { 7120.0f, 5.85930327f, 2.0181186f, 2.61870627f },
+    { 7140.0f, 10.1665465f, 2.54865502f, 2.57311398f },
+    { 7160.0f, 12.4658235f, 3.06611843f, 2.52752171f },
+    { 7180.0f, 12.2873253f, 3.58277771f, 2.48192944f },
+    { 7200.0f, 9.65794055f, 4.10483112f, 2.43633716f },
+    { 7220.0f, 5.10016266f, 4.6538533f, 2.39074488f },
+    { 7240.0f, 5.56392262f, 3.52247941f, 2.34515261f },
+    { 7260.0f, 6.02768257f, 2.39110552f, 2.29956034f },
+    { 7280.0f, 10.3451079f, 2.9307677f, 2.25396806f },
+    { 7300.0f, 12.6220565f, 3.45026417f, 2.20837579f },
+    { 7320.0f, 12.400915f, 3.96322385f, 2.16278351f },
+    { 7340.0f, 9.71997302f, 4.47035406f, 2.11719125f },
+    { 7360.0f, 5.10097621f, 4.96029343f, 2.07159898f },
+    { 7380.0f, 5.65159897f, 3.94066349f, 2.0260067f },
+    { 7400.0f, 6.20222174f, 2.92103356f, 1.98041442f },
+    { 7420.0f, 10.7188277f, 3.41211905f, 1.93482214f },
+    { 7440.0f, 13.2901693f, 3.91072111f, 1.88922987f },
+    { 7460.0f, 13.4603674f, 4.40543439f, 1.84363759f },
+    { 7480.0f, 11.2380126f, 4.88588941f, 1.79804532f },
+    { 7500.0f, 7.09486753f, 5.31741556f, 1.75245304f },
+    { 7520.0f, 2.10835141f, 5.31230836f, 1.7068608f },
+    { 7540.0f, 4.15172229f, 3.70700144f, 1.66126847f },
+    { 7560.0f, 8.7707745f, 4.02592813f, 1.61567622f },
+    { 7580.0f, 11.9077707f, 4.47413165f, 1.57008395f },
+    { 7600.0f, 13.0258073f, 4.94011211f, 1.52449167f },
+    { 7620.0f, 12.0455253f, 5.39793276f, 1.4788994f },
+    { 7640.0f, 9.29186026f, 5.81909511f, 1.43330713f },
+    { 7660.0f, 5.48067902f, 6.10828183f, 1.38771487f },
+    { 7680.0f, 2.47555659f, 5.63861334f, 1.34212258f },
+    { 7700.0f, 4.53437982f, 4.95803033f, 1.2965303f },
+    { 7720.0f, 7.46256217f, 5.18639419f, 1.25093803f },
+    { 7740.0f, 9.22753913f, 5.56477216f, 1.20534575f },
+    { 7760.0f, 9.55500915f, 5.96567735f, 1.15975348f },
+    { 7780.0f, 8.58793334f, 0.0627244363f, 1.1141612f },
+    { 7800.0f, 6.7466458f, 0.377020461f, 1.06856893f },
+    { 7820.0f, 4.68917292f, 0.533749947f, 1.02297665f },
+    { 7840.0f, 3.3873824f, 0.384086491f, 0.977384381f },
+    { 7860.0f, 3.57839182f, 0.138867852f, 0.931792107f },
+    { 7880.0f, 4.41550089f, 0.159069233f, 0.886199825f },
+    { 7900.0f, 5.06379286f, 0.331041042f, 0.840607558f },
+    { 7920.0f, 5.379915f, 0.546868274f, 0.795015284f },
+    { 7940.0f, 5.45757661f, 0.775236608f, 0.749423021f },
+    { 7960.0f, 5.35181622f, 1.0210656f, 0.70383072f },
+    { 7980.0f, 4.9879962f, 1.29339056f, 0.658238461f },
+    { 8000.0f, 4.23668182f, 1.58116595f, 0.612646187f },
+    { 8020.0f, 3.05956684f, 1.82517707f, 0.567053902f },
+    { 8040.0f, 1.74270077f, 1.76386986f, 0.521461635f },
+    { 8060.0f, 1.75488788f, 1.02624664f, 0.475869299f },
+    { 8080.0f, 3.23883341f, 0.996405943f, 0.430277096f },
+    { 8100.0f, 4.64390896f, 1.34213448f, 0.384684815f },
+    { 8120.0f, 5.44635973f, 1.79627837f, 0.33909254f },
+    { 8140.0f, 5.42470833f, 2.30315072f, 0.293500264f },
+    { 8160.0f, 4.53952243f, 2.85453411f, 0.247907991f },
+    { 8180.0f, 2.93215241f, 3.48638659f, 0.2023157f },
+    { 8200.0f, 1.0479925f, 4.60398693f, 0.156723441f },
+    { 8220.0f, 1.73908218f, 0.707270052f, 0.111131164f },
+    { 8240.0f, 3.62145524f, 1.52049319f, 0.0655388867f },
+    { 8253.75f, 4.62561425f, 1.96351762f, 0.0341942169f },
+    { 8254.75f, 4.68529751f, 1.99492718f, 0.0319143682f },
+    { 8255.75f, 4.74282216f, 2.02582897f, 0.0296350211f },
+    { 8256.75f, 4.7984656f, 2.0572129f, 0.0273550315f },
+    { 8257.75f, 4.85192864f, 2.08778695f, 0.025075871f },
+    { 8258.75f, 4.90339847f, 2.11930511f, 0.0227955925f },
+    { 8259.75f, 4.95291446f, 2.14949096f, 0.0205167512f },
+    { 8260.0f, 4.96447623f, 2.15779057f, 0.0199461874f },
+    { 8260.75f, 4.99987662f, 2.18131538f, 0.0182360074f },
+    { 8261.75f, 5.04575534f, 2.21095241f, 0.0159576996f },
+    { 8262.75f, 5.08774684f, 2.24347917f, 0.0136760628f },
+    { 8263.75f, 5.13170683f, 2.2723376f, 0.0113986315f },
+    { 8264.75f, 5.16684865f, 2.30646813f, 0.00911506929f },
+    { 8265.75f, 5.22178154f, 2.33685055f, 0.00683662087f },
+    { 8266.75f, 5.2370005f, 2.37145198f, 0.00455110344f },
+    { 8267.75f, 5.26456419f, 1.9333784f, 0.00456201387f },
+    { 8268.75f, 5.29212789f, 1.49530482f, 0.00457292431f },
+    { 8269.75f, 5.31969158f, 1.05723125f, 0.00458383474f },
+    { 8270.75f, 5.34725528f, 0.619157668f, 0.00459474517f },
+    { 8271.75f, 5.35347397f, 0.620378065f, 0.00684098682f },
+    { 8272.75f, 5.3907348f, 0.58742779f, 0.00912480819f },
+    { 8273.75f, 5.40594106f, 0.563117682f, 0.0113976153f },
+    { 8274.75f, 5.4240592f, 0.530219739f, 0.0136800631f },
+    { 8275.75f, 5.43656019f, 0.502101954f, 0.0159569903f },
+    { 8276.75f, 5.4477529f, 0.470259148f, 0.0182380647f },
+    { 8277.75f, 5.45598785f, 0.440838647f, 0.0205163738f },
+    { 8278.75f, 5.46189104f, 0.409532102f, 0.0227967672f },
+    { 8279.75f, 5.46544928f, 0.379507524f, 0.0250756906f },
+    { 8280.0f, 5.4656487f, 0.371491067f, 0.0256459869f },
+    { 8280.75f, 5.46639595f, 0.348450868f, 0.0273557268f },
+    { 8281.75f, 5.46526711f, 0.318072654f, 0.0296349731f },
+    { 8282.75f, 5.46145045f, 0.287116079f, 0.0319148128f },
+    { 8283.75f, 5.45546448f, 0.256517855f, 0.0341942261f },
+    { 8300.0f, 5.02964095f, 6.03007274f, 0.0712379328f },
+    { 8320.0f, 3.7559197f, 5.34422453f, 0.1168302f },
+    { 8340.0f, 2.04223842f, 4.38863597f, 0.162422477f },
+    { 8360.0f, 1.64507364f, 2.47554139f, 0.208014743f },
+    { 8380.0f, 3.355197f, 1.30375441f, 0.253607016f },
+    { 8400.0f, 4.94153235f, 0.584502185f, 0.2991993f },
+    { 8420.0f, 5.77459674f, 6.24210325f, 0.344791581f },
+    { 8440.0f, 5.63553673f, 5.64433378f, 0.390383853f },
+    { 8460.0f, 4.51901393f, 5.04552433f, 0.435976123f },
+    { 8480.0f, 2.62019983f, 4.38555169f, 0.481568392f },
+    { 8500.0f, 2.52304581f, 5.67445374f, 0.527160669f },
+    { 8520.0f, 2.42589179f, 0.680170484f, 0.572752947f },
+    { 8540.0f, 4.48231468f, 0.0315257459f, 0.618345221f },
+    { 8560.0f, 5.8300707f, 5.76679999f, 0.663937493f },
+    { 8580.0f, 6.21899098f, 5.25770856f, 0.709529769f },
+    { 8600.0f, 5.59559268f, 4.78499233f, 0.755122044f },
+    { 8620.0f, 4.10659357f, 4.37706439f, 0.800714331f },
+    { 8640.0f, 2.14042046f, 4.19698842f, 0.846306592f },
+    { 8660.0f, 1.34904371f, 5.1833772f, 0.89189884f },
+    { 8680.0f, 3.08585451f, 5.43136271f, 0.937491141f },
+    { 8700.0f, 4.71498734f, 5.14892176f, 0.983083415f },
+    { 8720.0f, 5.67404226f, 4.80183282f, 1.02867569f },
+    { 8740.0f, 5.86381317f, 4.46676334f, 1.07426795f },
+    { 8760.0f, 5.3902446f, 4.18388492f, 1.11986024f },
+    { 8780.0f, 4.53986087f, 4.00176048f, 1.16545253f },
+    { 8800.0f, 3.7726666f, 3.97819208f, 1.21104479f },
+    { 8820.0f, 3.58704961f, 4.08282177f, 1.25663706f },
+    { 8840.0f, 4.03532278f, 4.13539933f, 1.30222933f },
+    { 8860.0f, 4.70377832f, 4.06173303f, 1.34782161f },
+    { 8880.0f, 5.25206546f, 3.90953144f, 1.39341389f },
+    { 8900.0f, 5.53197242f, 3.72631946f, 1.43900616f },
+    { 8920.0f, 5.50959263f, 3.54302784f, 1.48459843f },
+    { 8940.0f, 5.23086463f, 3.3856513f, 1.53019071f },
+    { 8960.0f, 4.83523381f, 3.28036766f, 1.57578298f },
+    { 8980.0f, 4.55675553f, 3.23817566f, 1.62137526f },
+    { 9000.0f, 4.60019202f, 3.21893784f, 1.66696753f },
+    { 9020.0f, 4.91541844f, 3.15063159f, 1.7125598f },
+    { 9040.0f, 5.20730555f, 3.00787562f, 1.75815207f },
+    { 9060.0f, 5.17948887f, 2.81958518f, 1.80374435f },
+    { 9080.0f, 4.70927849f, 2.64077954f, 1.84933662f },
+    { 9100.0f, 3.95418515f, 2.55420047f, 1.8949289f },
+    { 9120.0f, 3.45912838f, 2.64380713f, 1.94052118f },
+    { 9140.0f, 3.82457313f, 2.77118172f, 1.98611346f },
+    { 9160.0f, 4.74727817f, 2.70024197f, 2.03170572f },
+    { 9180.0f, 5.48260257f, 2.46266081f, 2.077298f },
+    { 9200.0f, 5.552324f, 2.14510863f, 2.12289027f },
+    { 9220.0f, 4.77429414f, 1.80846963f, 2.16848254f },
+    { 9240.0f, 3.24112411f, 1.53916125f, 2.21407482f },
+    { 9260.0f, 1.5570538f, 1.7564663f, 2.2596671f },
+    { 9280.0f, 2.20452747f, 2.6615493f, 2.30525937f },
+    { 9300.0f, 4.12148857f, 2.53448106f, 2.35085165f },
+    { 9320.0f, 5.55866805f, 2.1572227f, 2.39644393f },
+    { 9340.0f, 6.08147395f, 1.71401023f, 2.44203619f },
+    { 9360.0f, 5.5484568f, 1.24280101f, 2.48762847f },
+    { 9380.0f, 4.03943422f, 0.756405349f, 2.53322074f },
+    { 9400.0f, 1.82432809f, 0.262106722f, 2.57881302f },
+    { 9420.0f, 2.44619965f, 1.32064281f, 2.62440528f },
+    { 9440.0f, 3.06807121f, 2.3791789f, 2.66999755f },
+    { 9460.0f, 4.8789134f, 1.86396001f, 2.71558985f },
+    { 9480.0f, 5.82933197f, 1.34223199f, 2.76118211f },
+    { 9500.0f, 5.78758148f, 0.81299526f, 2.80677439f },
+    { 9520.0f, 4.80708023f, 0.27105262f, 2.85236666f },
+    { 9540.0f, 3.10795829f, 5.97823851f, 2.89795894f },
+    { 9560.0f, 1.06500173f, 5.17012255f, 2.94355123f },
+    { 9580.0f, 1.23633978f, 2.28847544f, 2.98914352f },
+    { 9600.0f, 2.98760276f, 1.54818178f, 3.03473576f },
+    { 9620.0f, 4.18760715f, 0.980933566f, 3.08032806f },
+    { 9631.875f, 4.56332285f, 0.661060114f, 3.10739833f },
+    { 9632.875f, 4.58288858f, 0.634256287f, 3.10967814f },
+    { 9633.875f, 4.60076003f, 0.607917466f, 3.1119575f },
+    { 9634.875f, 4.61647079f, 0.581173599f, 3.11423735f },
+    { 9635.875f, 4.63075266f, 0.554947f, 3.11651667f },
+    { 9636.875f, 4.64258529f, 0.528340249f, 3.11879648f },
+    { 9637.875f, 4.65343835f, 0.502197952f, 3.1210758f },
+    { 9638.875f, 4.66125052f, 0.475873403f, 3.1233554f },
+    { 9639.875f, 4.66907977f, 0.449691098f, 3.12563489f },
+    { 9640.0f, 4.66948495f, 0.44742401f, 3.12591871f },
+    { 9640.875f, 4.67242552f, 0.424428365f, 3.12791351f },
+    { 9641.875f, 4.67871674f, 0.397484335f, 3.13019407f },
+    { 9642.875f, 4.67596448f, 0.377834226f, 3.13246708f },
+    { 9643.875f, 4.68896539f, 0.34495731f, 3.13475549f },
+    { 9644.875f, 4.67925044f, 0.780474582f, 3.13475512f },
+    { 9645.875f, 4.66953549f, 1.21599185f, 3.13475475f },
+    { 9646.875f, 4.65982054f, 1.65150913f, 3.13475438f },
+    { 9647.875f, 4.6501056f, 2.0870264f, 3.13475401f },
+    { 9648.875f, 4.64039065f, 2.52254367f, 3.13475364f },
+    { 9649.875f, 4.6306757f, 2.95806094f, 3.13475328f },
+    { 9650.875f, 4.6205073f, 2.99174459f, 3.1324625f },
+    { 9651.875f, 4.60695855f, 3.00645832f, 3.13019461f },
+    { 9652.875f, 4.59017543f, 3.03506155f, 3.1279116f },
+    { 9653.875f, 4.57292386f, 3.05778615f, 3.12563529f },
+    { 9654.875f, 4.55278699f, 3.08462623f, 3.12335442f },
+    { 9655.875f, 4.53196089f, 3.10926344f, 3.12107602f },
+    { 9656.875f, 4.50873182f, 3.13540429f, 3.11879591f },
+    { 9657.875f, 4.48458931f, 3.16065364f, 3.11651678f },
+    { 9658.875f, 4.45828182f, 3.1864759f, 3.11423698f },
+    { 9659.875f, 4.43090856f, 3.21193556f, 3.11195755f },
+    { 9660.0f, 4.42718331f, 3.21502037f, 3.11167273f },
+    { 9660.875f, 4.4016175f, 3.23755871f, 3.10967791f },
+    { 9661.875f, 4.37110264f, 3.26305697f, 3.10739834f },
+    { 9680.0f, 3.58350391f, 3.71939588f, 3.06608044f },
+    { 9700.0f, 2.34115804f, 4.20077734f, 3.02048818f },
+    { 9720.0f, 2.07808719f, 3.67668776f, 2.97489591f },
+    { 9740.0f, 1.81501634f, 3.15259818f, 2.92930364f },
+    { 9760.0f, 1.55194549f, 2.6285086f, 2.88371137f },
+    { 9780.0f, 2.36689938f, 3.03466575f, 2.83811908f },
+    { 9800.0f, 2.85704216f, 3.44145088f, 2.7925268f },
+    { 9820.0f, 3.05009743f, 3.83940836f, 2.74693453f },
+    { 9840.0f, 2.97908011f, 4.23388911f, 2.70134226f },
+    { 9860.0f, 2.65243266f, 4.63429972f, 2.65574997f },
+    { 9880.0f, 2.05427769f, 5.04672722f, 2.61015769f },
+    { 9900.0f, 1.17455629f, 5.4603194f, 2.56456543f },
+    { 9920.0f, 1.21202193f, 4.43988963f, 2.51897316f },
+    { 9940.0f, 1.24948756f, 3.41945987f, 2.47338088f },
+    { 9960.0f, 2.53077617f, 3.89590347f, 2.42778861f },
+    { 9980.0f, 3.61097705f, 4.41518208f, 2.38219634f },
+    { 10000.0f, 4.2887424f, 4.95884613f, 2.33660406f },
+    { 10020.0f, 4.40410696f, 5.52681081f, 2.29101179f },
+    { 10040.0f, 3.87943012f, 6.13059515f, 2.24541952f },
+    { 10060.0f, 2.75993458f, 0.534877925f, 2.19982724f },
+    { 10080.0f, 1.35879933f, 1.60360409f, 2.15423496f },
+    { 10100.0f, 1.53404022f, 3.68082627f, 2.10864269f },
+    { 10120.0f, 3.25613886f, 4.69225063f, 2.06305043f },
+    { 10140.0f, 4.8430858f, 5.39504888f, 2.01745814f },
+    { 10160.0f, 5.87295379f, 6.03913812f, 1.97186587f },
+    { 10180.0f, 6.13161232f, 0.389662224f, 1.92627359f },
+    { 10200.0f, 5.54610868f, 1.03766209f, 1.88068132f },
+    { 10220.0f, 4.20339583f, 1.74035993f, 1.83508904f },
+    { 10240.0f, 2.43011223f, 2.6563981f, 1.78949675f },
+    { 10260.0f, 1.61811049f, 4.43916614f, 1.74390449f },
+    { 10280.0f, 3.19455732f, 5.80811245f, 1.69831221f },
+    { 10300.0f, 4.9684118f, 0.321817592f, 1.65271994f },
+    { 10320.0f, 6.15487228f, 1.00245852f, 1.60712767f },
+    { 10340.0f, 6.49707365f, 1.6532787f, 1.56153539f },
+    { 10360.0f, 5.93239657f, 2.30615103f, 1.51594312f },
+    { 10380.0f, 4.57225784f, 2.99652723f, 1.47035085f },
+    { 10400.0f, 2.73168371f, 3.83790417f, 1.42475857f },
+    { 10420.0f, 1.43426057f, 5.43591157f, 1.37916628f },
+    { 10440.0f, 2.58883063f, 0.768230026f, 1.33357402f },
+    { 10460.0f, 4.158893f, 1.61596908f, 1.28798176f },
+    { 10480.0f, 5.15006485f, 2.31199504f, 1.24238947f },
+    { 10500.0f, 5.34510835f, 2.9752187f, 1.1967972f },
+    { 10520.0f, 4.75049579f, 3.64827699f, 1.15120491f },
+    { 10540.0f, 3.54971962f, 4.38224271f, 1.10561265f },
+    { 10560.0f, 2.13880543f, 5.33328631f, 1.06002038f },
+    { 10580.0f, 1.50345586f, 0.617424066f, 1.01442812f },
+    { 10600.0f, 2.2898715f, 1.96019492f, 0.968835829f },
+    { 10620.0f, 3.14856009f, 2.82344889f, 0.923243555f },
+    { 10640.0f, 3.52421623f, 3.56764095f, 0.877651281f },
+    { 10660.0f, 3.35750092f, 4.30618958f, 0.832059023f },
+    { 10680.0f, 2.7960927f, 5.10892815f, 0.786466733f },
+    { 10700.0f, 2.15067062f, 6.06472446f, 0.740874458f },
+    { 10720.0f, 1.82698431f, 0.925917244f, 0.695282178f },
+    { 10740.0f, 1.92407991f, 2.03505768f, 0.64968991f },
+    { 10760.0f, 2.07148331f, 2.97583326f, 0.604097636f },
+    { 10780.0f, 2.0050996f, 3.84835523f, 0.558505361f },
+    { 10800.0f, 1.74773902f, 4.77976972f, 0.512913086f },
+    { 10820.0f, 1.55821451f, 5.8633688f, 0.467320807f },
+    { 10840.0f, 1.69953207f, 0.683976896f, 0.421728533f },
+    { 10860.0f, 2.02506668f, 1.59696111f, 0.376136263f },
+    { 10880.0f, 2.21469148f, 2.35042378f, 0.330543999f },
+    { 10900.0f, 2.08587245f, 3.02830563f, 0.284951715f },
+    { 10920.0f, 1.60500991f, 3.70118795f, 0.23935944f },
+    { 10940.0f, 1.48740794f, 2.96235105f, 0.193767164f },
+    { 10960.0f, 1.36980596f, 2.22351415f, 0.148174888f },
+    { 10980.0f, 1.25220399f, 1.48467725f, 0.102582612f },
+    { 11000.0f, 1.96613962f, 2.13975739f, 0.0569903422f },
+    { 11010.0f, 2.21934369f, 2.41980929f, 0.034194314f },
+    { 11011.0f, 2.23983029f, 2.44712499f, 0.0319145019f },
+    { 11012.0f, 2.25948113f, 2.47388132f, 0.0296351508f },
+    { 11013.0f, 2.27810961f, 2.50097424f, 0.027355284f },
+    { 11014.0f, 2.29592197f, 2.52743137f, 0.0250759877f },
+    { 11015.0f, 2.31257596f, 2.55429446f, 0.022796096f },
+    { 11016.0f, 2.32867006f, 2.58046581f, 0.0205168617f },
+    { 11017.0f, 2.34318971f, 2.60696475f, 0.0182370991f },
+    { 11018.0f, 2.35770557f, 2.63299595f, 0.0159577682f },
+    { 11019.0f, 2.36985865f, 2.6585249f, 0.0136787604f },
+    { 11020.0f, 2.38347994f, 2.68497307f, 0.0113986189f },
+    { 11021.0f, 2.39239016f, 2.70555342f, 0.0091244027f },
+    { 11022.0f, 2.40988797f, 2.73752689f, 0.00683697751f },
+    { 11023.0f, 2.41020636f, 2.6951924f, 0.00462588015f },
+    { 11024.0f, 3.06698155f, 4.71238878f, 2.27178495e-10f },
+    { 11025.0f, 1.55608287f, 1.57079627f, 5.36295678e-11f },
+};
+
+static const TPqfWidebandPoint PqfWidebandTable3[] = {
+    { 1.0f, 6.76802772f, 3.43323516f, 0.00170504633f },
+    { 2.0f, 6.49466296f, 3.00843666f, 0.00465665774f },
+    { 3.0f, 6.49804979f, 3.0883545f, 0.00683828771f },
+    { 4.0f, 6.48225531f, 3.06317133f, 0.00912967135f },
+    { 5.0f, 6.47518321f, 3.05711645f, 0.0113982931f },
+    { 6.0f, 6.45942672f, 3.03827481f, 0.0136806828f },
+    { 7.0f, 6.44562026f, 3.02428634f, 0.0159575517f },
+    { 8.0f, 6.42658773f, 3.00701556f, 0.0182380194f },
+    { 9.0f, 6.40731012f, 2.99132678f, 0.0205167437f },
+    { 10.0f, 6.38409634f, 2.97462891f, 0.0227966107f },
+    { 11.0f, 6.35982805f, 2.95846408f, 0.0250759339f },
+    { 12.0f, 6.33228267f, 2.94205539f, 0.0273555802f },
+    { 13.0f, 6.30323631f, 2.92580444f, 0.0296351238f },
+    { 14.0f, 6.27129963f, 2.90959662f, 0.0319146904f },
+    { 15.0f, 6.23758243f, 2.8933997f, 0.0341943258f },
+    { 20.0f, 6.03459518f, 2.81397935f, 0.0455922803f },
+    { 40.0f, 4.73669801f, 2.54042124f, 0.091184547f },
+    { 60.0f, 3.02093573f, 2.47711793f, 0.136776824f },
+    { 80.0f, 2.27354129f, 3.01706706f, 0.18236907f },
+    { 100.0f, 3.71251198f, 3.315457f, 0.227961372f },
+    { 120.0f, 5.51530392f, 3.11760979f, 0.273553646f },
+    { 140.0f, 6.71931535f, 2.76986097f, 0.31914592f },
+    { 160.0f, 6.97179755f, 2.36455573f, 0.364738197f },
+    { 180.0f, 6.16196735f, 1.92948073f, 0.410330469f },
+    { 200.0f, 4.37661992f, 1.47755207f, 0.455922743f },
+    { 220.0f, 1.87486863f, 1.03418864f, 0.501515032f },
+    { 240.0f, 2.79158205f, 2.05724876f, 0.547107298f },
+    { 260.0f, 3.70829547f, 3.08030889f, 0.592699563f },
+    { 280.0f, 5.93317335f, 2.56084354f, 0.638291841f },
+    { 300.0f, 7.33094298f, 2.01072529f, 0.683884115f },
+    { 320.0f, 7.7382525f, 1.42794446f, 0.729476392f },
+    { 340.0f, 7.16623925f, 0.799482313f, 0.775068666f },
+    { 360.0f, 5.80435175f, 0.0917329174f, 0.820660938f },
+    { 380.0f, 4.0672994f, 5.48805195f, 0.86625321f },
+    { 400.0f, 2.95918098f, 4.18056161f, 0.911845487f },
+    { 420.0f, 3.86397564f, 2.77672451f, 0.957437761f },
+    { 440.0f, 5.85973306f, 1.79420253f, 1.00303004f },
+    { 460.0f, 7.83125524f, 1.00330511f, 1.04862231f },
+    { 480.0f, 9.30026643f, 0.281034846f, 1.09421458f },
+    { 500.0f, 9.95528472f, 5.86746207f, 1.13980686f },
+    { 520.0f, 9.57691531f, 5.16948588f, 1.18539914f },
+    { 540.0f, 8.11126581f, 4.43088171f, 1.23099141f },
+    { 560.0f, 5.87589373f, 3.54592221f, 1.27658368f },
+    { 580.0f, 4.30751937f, 2.23995477f, 1.32217596f },
+    { 600.0f, 5.86125697f, 0.845145715f, 1.36776823f },
+    { 620.0f, 9.02705696f, 6.2060153f, 1.4133605f },
+    { 640.0f, 11.7631383f, 5.48380561f, 1.45895278f },
+    { 660.0f, 13.1340511f, 4.82597227f, 1.50454505f },
+    { 680.0f, 12.6920195f, 4.17917609f, 1.55013733f },
+    { 700.0f, 10.4259133f, 3.49534931f, 1.5957296f },
+    { 720.0f, 6.92870179f, 2.65376281f, 1.64132188f },
+    { 740.0f, 4.48802095f, 1.24443931f, 1.68691416f },
+    { 760.0f, 6.81538843f, 6.07341468f, 1.73250643f },
+    { 780.0f, 10.565442f, 5.21696912f, 1.7780987f },
+    { 800.0f, 13.1186901f, 4.53573835f, 1.82369097f },
+    { 820.0f, 13.6265922f, 3.89673874f, 1.86928324f },
+    { 840.0f, 11.9208563f, 3.24338689f, 1.91487552f },
+    { 860.0f, 8.46367218f, 2.49099875f, 1.96046781f },
+    { 880.0f, 4.90891792f, 1.32658209f, 2.00606007f },
+    { 900.0f, 5.71900421f, 5.96126645f, 2.05165235f },
+    { 920.0f, 9.44785722f, 4.98294604f, 2.09724462f },
+    { 940.0f, 12.2410894f, 4.27787032f, 2.14283689f },
+    { 960.0f, 12.9445664f, 3.63748628f, 2.18842917f },
+    { 980.0f, 11.3156709f, 2.99160729f, 2.23402144f },
+    { 1000.0f, 7.79299353f, 2.24949475f, 2.27961372f },
+    { 1020.0f, 4.11166049f, 1.01527356f, 2.32520599f },
+    { 1040.0f, 5.54174833f, 5.53742295f, 2.37079827f },
+    { 1060.0f, 9.63154654f, 4.62673211f, 2.41639054f },
+    { 1080.0f, 12.5181318f, 3.95905117f, 2.46198281f },
+    { 1100.0f, 13.1895464f, 3.34728347f, 2.50757509f },
+    { 1120.0f, 11.4282063f, 2.73604953f, 2.55316736f },
+    { 1140.0f, 7.62515707f, 2.0562914f, 2.59875964f },
+    { 1160.0f, 3.19123595f, 0.885633371f, 2.6443519f },
+    { 1180.0f, 4.73727649f, 5.05063091f, 2.6899442f },
+    { 1200.0f, 9.28531868f, 4.20372653f, 2.73553646f },
+    { 1220.0f, 12.4497864f, 3.58101136f, 2.78112874f },
+    { 1240.0f, 13.3727468f, 3.00592944f, 2.82672101f },
+    { 1260.0f, 11.8587233f, 2.44117355f, 2.87231328f },
+    { 1280.0f, 8.22765719f, 1.85789554f, 2.91790555f },
+    { 1300.0f, 3.28644391f, 1.10844507f, 2.96349783f },
+    { 1320.0f, 2.67674537f, 4.52136729f, 3.00909011f },
+    { 1340.0f, 7.39616677f, 3.70888376f, 3.05468239f },
+    { 1360.0f, 10.7493564f, 3.13653751f, 3.10027454f },
+    { 1363.125f, 11.0964723f, 3.05139208f, 3.10739838f },
+    { 1364.125f, 11.1960527f, 3.02443952f, 3.10967786f },
+    { 1365.125f, 11.2908583f, 2.99728537f, 3.11195763f },
+    { 1366.125f, 11.3793447f, 2.97061798f, 3.11423693f },
+    { 1367.125f, 11.4631878f, 2.94343465f, 3.11651688f },
+    { 1368.125f, 11.5404656f, 2.91719766f, 3.11879584f },
+    { 1369.125f, 11.6130903f, 2.88981402f, 3.12107616f },
+    { 1370.125f, 11.6790891f, 2.86436572f, 3.12335439f },
+    { 1371.125f, 11.7399303f, 2.83644231f, 3.12563549f },
+    { 1372.125f, 11.7948484f, 2.81285332f, 3.12791185f },
+    { 1373.125f, 11.8415889f, 2.78351748f, 3.13019487f },
+    { 1374.125f, 11.8870241f, 2.7665216f, 3.13246436f },
+    { 1375.125f, 11.8997469f, 2.73455899f, 3.13475232f },
+    { 1376.125f, 11.9319903f, 2.28135263f, 3.13528381f },
+    { 1377.125f, 11.9642338f, 1.82814628f, 3.13581531f },
+    { 1378.125f, 11.9964772f, 1.37493993f, 3.1363468f },
+    { 1379.125f, 12.0287206f, 0.921733574f, 3.13687829f },
+    { 1380.0f, 12.0569337f, 0.525178015f, 3.13734335f },
+    { 1380.125f, 12.0288364f, 0.5839632f, 3.13699424f },
+    { 1381.125f, 12.0804333f, 0.568295951f, 3.13475598f },
+    { 1382.125f, 12.0347051f, 0.598230535f, 3.13247191f },
+    { 1383.125f, 12.0370243f, 0.622430813f, 3.13019399f },
+    { 1384.125f, 12.0145893f, 0.647960329f, 3.12791498f },
+    { 1385.125f, 11.9989299f, 0.674367693f, 3.12563488f },
+    { 1386.125f, 11.9712951f, 0.699719541f, 3.12335601f },
+    { 1387.125f, 11.9423251f, 0.726195673f, 3.12107581f },
+    { 1388.125f, 11.9052987f, 0.7516174f, 3.11879677f },
+    { 1389.125f, 11.8644118f, 0.777930402f, 3.11651669f },
+    { 1390.125f, 11.8169575f, 0.803414073f, 3.11423749f },
+    { 1391.125f, 11.7646408f, 0.829538573f, 3.11195754f },
+    { 1392.125f, 11.7065418f, 0.855065523f, 3.10967821f },
+    { 1393.125f, 11.6431649f, 0.881010562f, 3.10739837f },
+    { 1400.0f, 11.0633516f, 1.05675736f, 3.0917261f },
+    { 1420.0f, 8.10336149f, 1.55274953f, 3.04613384f },
+    { 1440.0f, 3.79617635f, 1.97591986f, 3.00054156f },
+    { 1460.0f, 1.27738132f, 0.0370907764f, 2.95494927f },
+    { 1480.0f, 5.5858833f, 0.131919629f, 2.90935701f },
+    { 1500.0f, 8.8135809f, 0.586809851f, 2.86376473f },
+    { 1520.0f, 10.3160449f, 1.06143012f, 2.81817246f },
+    { 1540.0f, 9.90847808f, 1.5272932f, 2.77258018f },
+    { 1560.0f, 7.79104918f, 1.95781016f, 2.72698791f },
+    { 1580.0f, 4.54761275f, 2.25897554f, 2.68139563f },
+    { 1600.0f, 1.90861306f, 1.68008245f, 2.63580336f },
+    { 1620.0f, 4.10938037f, 0.989644782f, 2.59021109f },
+    { 1640.0f, 6.8408212f, 1.25236126f, 2.54461881f },
+    { 1660.0f, 8.40233153f, 1.63808436f, 2.49902654f },
+    { 1680.0f, 8.53011647f, 2.03217159f, 2.45343426f },
+    { 1700.0f, 7.36724237f, 2.38335638f, 2.40784199f },
+    { 1720.0f, 5.42721138f, 2.60816785f, 2.36224972f },
+    { 1740.0f, 3.77881069f, 2.51752249f, 2.31665744f },
+    { 1760.0f, 3.93176021f, 2.19592028f, 2.27106518f },
+    { 1780.0f, 5.25901158f, 2.19718457f, 2.2254729f },
+    { 1800.0f, 6.28497519f, 2.40930954f, 2.17988062f },
+    { 1820.0f, 6.5360462f, 2.66594235f, 2.13428834f },
+    { 1840.0f, 6.11426479f, 2.88146742f, 2.08869607f },
+    { 1860.0f, 5.48410065f, 2.99801747f, 2.04310379f },
+    { 1880.0f, 5.24012004f, 3.02432761f, 1.99751152f },
+    { 1900.0f, 5.55500412f, 3.07349961f, 1.95191925f },
+    { 1920.0f, 5.9932233f, 3.21415814f, 1.90632697f },
+    { 1940.0f, 6.08555442f, 3.41007577f, 1.8607347f },
+    { 1960.0f, 5.69717144f, 3.59313139f, 1.81514242f },
+    { 1980.0f, 5.08096192f, 3.69264827f, 1.76955015f },
+    { 2000.0f, 4.78977126f, 3.684027f, 1.72395787f },
+    { 2020.0f, 5.18072378f, 3.67895974f, 1.6783656f },
+    { 2040.0f, 5.91856137f, 3.78877489f, 1.63277332f },
+    { 2060.0f, 6.43814457f, 3.99127634f, 1.58718106f },
+    { 2080.0f, 6.42840454f, 4.2225614f, 1.54158879f },
+    { 2100.0f, 5.91185769f, 4.42130783f, 1.4959965f },
+    { 2120.0f, 5.22483901f, 4.53130925f, 1.45040423f },
+    { 2140.0f, 4.8769415f, 4.54697135f, 1.40481195f },
+    { 2160.0f, 5.07680325f, 4.57094418f, 1.35921968f },
+    { 2180.0f, 5.44481585f, 4.68556275f, 1.3136274f },
+    { 2200.0f, 5.50305074f, 4.8596065f, 1.26803513f },
+    { 2220.0f, 5.10080213f, 5.01450202f, 1.22244286f },
+    { 2240.0f, 4.54392867f, 5.06174611f, 1.17685058f },
+    { 2260.0f, 4.5154984f, 4.99692634f, 1.1312583f },
+    { 2280.0f, 5.2916415f, 5.00614608f, 1.08566603f },
+    { 2300.0f, 6.25426073f, 5.18230765f, 1.04007376f },
+    { 2320.0f, 6.67627231f, 5.46493248f, 0.994481489f },
+    { 2340.0f, 6.14308669f, 5.78298068f, 0.94888921f },
+    { 2360.0f, 4.60522713f, 6.05011954f, 0.903296941f },
+    { 2380.0f, 2.62284551f, 5.97547749f, 0.857704661f },
+    { 2400.0f, 2.82767043f, 5.19098564f, 0.812112387f },
+    { 2420.0f, 5.33024376f, 5.176125f, 0.766520111f },
+    { 2440.0f, 7.58395492f, 5.50353579f, 0.720927839f },
+    { 2460.0f, 8.71740223f, 5.91710186f, 0.675335564f },
+    { 2480.0f, 8.34006603f, 0.0753265914f, 0.629743288f },
+    { 2500.0f, 6.39492673f, 0.514854391f, 0.584151015f },
+    { 2520.0f, 3.17394619f, 0.87260167f, 0.538558741f },
+    { 2540.0f, 1.21000829f, 5.41132996f, 0.492966448f },
+    { 2560.0f, 5.06475573f, 5.37893907f, 0.447374191f },
+    { 2580.0f, 8.35351078f, 5.81130512f, 0.401781917f },
+    { 2600.0f, 10.2342883f, 0.00149602189f, 0.356189643f },
+    { 2620.0f, 10.2704456f, 0.485510701f, 0.310597366f },
+    { 2640.0f, 8.37754388f, 0.969445296f, 0.265005094f },
+    { 2660.0f, 4.85047964f, 1.43432608f, 0.21941282f },
+    { 2680.0f, 4.64185064f, 0.43647373f, 0.173820545f },
+    { 2700.0f, 4.43322163f, 5.72180668f, 0.128228271f },
+    { 2720.0f, 8.396983f, 6.18064423f, 0.0826360064f },
+    { 2740.0f, 10.8341361f, 0.381587955f, 0.0370437786f },
+    { 2741.25f, 10.9219462f, 0.412092531f, 0.0341941884f },
+    { 2742.25f, 10.9862266f, 0.436248228f, 0.0319148029f },
+    { 2743.25f, 11.0454877f, 0.460841674f, 0.0296349243f },
+    { 2744.25f, 11.0991917f, 0.484856513f, 0.0273556983f },
+    { 2745.25f, 11.1476249f, 0.509615582f, 0.025075635f },
+    { 2746.25f, 11.1907057f, 0.533379639f, 0.0227966877f },
+    { 2747.25f, 11.2279614f, 0.558416227f, 0.0205163017f },
+    { 2748.25f, 11.2605848f, 0.581709215f, 0.0182378716f },
+    { 2749.25f, 11.2856205f, 0.607228759f, 0.015956912f },
+    { 2750.25f, 11.3086274f, 0.629557291f, 0.0136795452f },
+    { 2751.25f, 11.3175987f, 0.655897272f, 0.0113975356f },
+    { 2752.25f, 11.3344594f, 0.675664869f, 0.00912300002f },
+    { 2753.25f, 11.2999582f, 0.700944884f, 0.00684112678f },
+    { 2754.25f, 11.337433f, 0.7080947f, 0.00458030479f },
+    { 2755.25f, 11.3243168f, 1.11433491f, 0.00457041179f },
+    { 2756.25f, 11.3112005f, 1.52057512f, 0.00456051879f },
+    { 2757.25f, 11.2980843f, 1.92681533f, 0.00455062579f },
+    { 2758.25f, 11.284968f, 2.33305554f, 0.00454073279f },
+    { 2759.25f, 11.2947338f, 2.29457092f, 0.00683666191f },
+    { 2760.0f, 11.2500841f, 2.27864047f, 0.00854308736f },
+    { 2760.25f, 11.2214207f, 2.27110686f, 0.00911425722f },
+    { 2761.25f, 11.1887789f, 2.24262523f, 0.011398601f },
+    { 2762.25f, 11.1370225f, 2.2202989f, 0.0136759142f },
+    { 2763.25f, 11.0884822f, 2.1941408f, 0.0159576857f },
+    { 2764.25f, 11.0309483f, 2.17107287f, 0.0182359834f },
+    { 2765.25f, 10.9702801f, 2.145851f, 0.0205167528f },
+    { 2766.25f, 10.9032393f, 2.12236134f, 0.0227955975f },
+    { 2767.25f, 10.8313879f, 2.09762549f, 0.0250758753f },
+    { 2768.25f, 10.7541226f, 2.07391392f, 0.0273550306f },
+    { 2769.25f, 10.6714446f, 2.04947171f, 0.0296350364f },
+    { 2770.25f, 10.5837041f, 2.02564684f, 0.0319143796f },
+    { 2771.25f, 10.4905048f, 2.00140489f, 0.0341942277f },
+    { 2780.0f, 9.45999973f, 1.79273613f, 0.0541408186f },
+    { 2800.0f, 5.83448129f, 1.34059913f, 0.0997330925f },
+    { 2820.0f, 1.15408373f, 1.30245257f, 0.145325373f },
+    { 2840.0f, 4.14639494f, 3.24592631f, 0.190917654f },
+    { 2860.0f, 8.4536569f, 2.83479403f, 0.236509921f },
+    { 2880.0f, 11.1536661f, 2.37210876f, 0.282102197f },
+    { 2900.0f, 11.6644398f, 1.90702712f, 0.327694472f },
+    { 2920.0f, 9.85009649f, 1.45938057f, 0.373286745f },
+    { 2940.0f, 6.07836203f, 1.08376007f, 0.418879021f },
+    { 2960.0f, 1.75138562f, 1.47610706f, 0.464471296f },
+    { 2980.0f, 4.90617293f, 2.67663226f, 0.510063565f },
+    { 3000.0f, 9.31023603f, 2.36512729f, 0.555655844f },
+    { 3020.0f, 12.0039867f, 1.94658474f, 0.601248116f },
+    { 3040.0f, 12.3079491f, 1.51826085f, 0.64684039f },
+    { 3060.0f, 10.1068719f, 1.12209287f, 0.692432666f },
+    { 3080.0f, 5.96599617f, 0.879477158f, 0.738024941f },
+    { 3100.0f, 2.98291198f, 1.67539761f, 0.783617215f },
+    { 3120.0f, 7.16222486f, 2.16056631f, 0.829209489f },
+    { 3140.0f, 11.7136585f, 1.87255188f, 0.874801766f },
+    { 3160.0f, 14.2001946f, 1.47805314f, 0.920394043f },
+    { 3180.0f, 13.7981911f, 1.07178594f, 0.965986312f },
+    { 3200.0f, 10.4050407f, 0.715601065f, 1.01157859f },
+    { 3220.0f, 5.04235576f, 0.688875093f, 1.05717086f },
+    { 3240.0f, 5.46825542f, 1.88298648f, 1.10276314f },
+    { 3260.0f, 12.5025269f, 1.83405662f, 1.14835541f },
+    { 3280.0f, 18.5742166f, 1.46628886f, 1.19394768f },
+    { 3300.0f, 21.7000905f, 1.0410979f, 1.23953996f },
+    { 3320.0f, 20.8023223f, 0.606491716f, 1.28513223f },
+    { 3340.0f, 15.596508f, 0.199584733f, 1.3307245f },
+    { 3360.0f, 6.92196936f, 0.0094076633f, 1.37631678f },
+    { 3380.0f, 6.42880448f, 1.65368261f, 1.42190906f },
+    { 3400.0f, 17.9957459f, 1.5257942f, 1.46750133f },
+    { 3420.0f, 28.2346398f, 1.11497467f, 1.5130936f },
+    { 3440.0f, 34.4993127f, 0.662425866f, 1.55868588f },
+    { 3460.0f, 35.020803f, 0.200371732f, 1.60427815f },
+    { 3480.0f, 28.9736196f, 6.02919638f, 1.64987043f },
+    { 3500.0f, 16.7663065f, 5.6312552f, 1.6954627f },
+    { 3520.0f, 3.31053804f, 0.410820951f, 1.74105498f },
+    { 3540.0f, 19.7990271f, 1.15686807f, 1.78664725f },
+    { 3560.0f, 37.0623305f, 0.747267743f, 1.83223952f },
+    { 3580.0f, 49.070237f, 0.2838703f, 1.8778318f },
+    { 3600.0f, 52.3884468f, 6.09253551f, 1.92342407f },
+    { 3620.0f, 44.7744271f, 5.6217712f, 1.96901635f },
+    { 3640.0f, 25.8803052f, 5.19119291f, 2.01460862f },
+    { 3660.0f, 4.43147308f, 0.499685099f, 2.0602009f },
+    { 3680.0f, 35.5751725f, 0.82796687f, 2.10579317f },
+    { 3700.0f, 64.5817052f, 0.378961612f, 2.15138545f },
+    { 3720.0f, 78.8637329f, 6.1812659f, 2.19697772f },
+    { 3740.0f, 64.3359772f, 5.69572378f, 2.24256999f },
+    { 3760.0f, 4.65753763f, 5.4833576f, 2.28816228f },
+    { 3780.0f, 119.206291f, 1.52800613f, 2.33375454f },
+    { 3800.0f, 326.195981f, 1.03590143f, 2.37934682f },
+    { 3820.0f, 636.480793f, 0.537324835f, 2.42493909f },
+    { 3840.0f, 1069.44529f, 0.0367814186f, 2.47053137f },
+    { 3860.0f, 1642.9629f, 5.81845417f, 2.51612364f },
+    { 3880.0f, 2372.38572f, 5.31636928f, 2.56171591f },
+    { 3900.0f, 3269.51382f, 4.81392041f, 2.60730819f },
+    { 3920.0f, 4341.57965f, 4.31123451f, 2.65290046f },
+    { 3940.0f, 5590.30469f, 3.80839433f, 2.69849274f },
+    { 3960.0f, 7011.10506f, 3.30545816f, 2.74408501f },
+    { 3980.0f, 8592.5402f, 2.80246535f, 2.78967729f },
+    { 4000.0f, 10316.1014f, 2.29944488f, 2.83526956f },
+    { 4020.0f, 12156.4331f, 1.79641548f, 2.88086184f },
+    { 4040.0f, 14082.0352f, 1.2933917f, 2.92645411f },
+    { 4060.0f, 16056.4883f, 0.790381826f, 2.97204638f },
+    { 4080.0f, 18040.1044f, 0.287390419f, 3.01763866f },
+    { 4100.0f, 19992.0323f, 6.06761716f, 3.06323092f },
+    { 4119.375f, 21814.7961f, 5.58029595f, 3.10739853f },
+    { 4120.0f, 21871.8904f, 5.56458164f, 3.10882329f },
+    { 4120.375f, 21906.4306f, 5.55535863f, 3.10967791f },
+    { 4121.375f, 21997.4818f, 5.52995527f, 3.11195781f },
+    { 4122.375f, 22088.8542f, 5.5051039f, 3.11423709f },
+    { 4123.375f, 22178.7449f, 5.47959052f, 3.11651711f },
+    { 4124.375f, 22270.1803f, 5.45484324f, 3.11879627f },
+    { 4125.375f, 22358.1267f, 5.42918558f, 3.12107645f },
+    { 4126.375f, 22450.4242f, 5.40452323f, 3.1233555f },
+    { 4127.375f, 22534.2536f, 5.3787136f, 3.12563585f },
+    { 4128.375f, 22629.713f, 5.35387971f, 3.12791501f },
+    { 4129.375f, 22701.3097f, 5.32820015f, 3.13019518f },
+    { 4130.375f, 22808.7672f, 5.30100951f, 3.1324766f },
+    { 4131.375f, 22813.8023f, 5.27982679f, 3.13475153f },
+    { 4132.375f, 22997.8106f, 5.20890404f, 3.13707527f },
+    { 4133.375f, 23093.391f, 5.02565815f, 3.13661127f },
+    { 4134.375f, 23188.9714f, 4.84241227f, 3.13614727f },
+    { 4135.375f, 23284.5519f, 4.65916639f, 3.13568327f },
+    { 4136.375f, 23380.1323f, 4.4759205f, 3.13521928f },
+    { 4137.375f, 23475.7127f, 4.29267462f, 3.13475528f },
+    { 4138.375f, 23511.3217f, 4.3123362f, 3.132484f },
+    { 4139.375f, 23600.0907f, 4.34696448f, 3.1301943f },
+    { 4140.0f, 23647.6339f, 4.36292404f, 3.12876949f },
+    { 4140.375f, 23679.506f, 4.36936545f, 3.12791808f },
+    { 4141.375f, 23763.803f, 4.39753252f, 3.12563521f },
+    { 4142.375f, 23848.1714f, 4.42142538f, 3.12335709f },
+    { 4143.375f, 23931.2562f, 4.44784958f, 3.12107609f },
+    { 4144.375f, 24015.9551f, 4.47238896f, 3.11879719f },
+    { 4145.375f, 24098.4237f, 4.49814172f, 3.11651692f },
+    { 4146.375f, 24182.5111f, 4.52299157f, 3.11423765f },
+    { 4147.375f, 24264.4609f, 4.54843387f, 3.11195772f },
+    { 4148.375f, 24347.7011f, 4.57344536f, 3.10967827f },
+    { 4149.375f, 24429.1157f, 4.59872933f, 3.10739851f },
+    { 4160.0f, 25278.0442f, 4.86594122f, 3.08317759f },
+    { 4180.0f, 26748.2473f, 5.3688974f, 3.03758528f },
+    { 4200.0f, 28039.5629f, 5.87180302f, 2.991993f },
+    { 4220.0f, 29144.9151f, 0.0915270746f, 2.94640073f },
+    { 4240.0f, 30065.6186f, 0.594441144f, 2.90080845f },
+    { 4260.0f, 30810.5784f, 1.09736617f, 2.85521618f },
+    { 4280.0f, 31394.8294f, 1.60030394f, 2.80962391f },
+    { 4300.0f, 31837.8194f, 2.10325383f, 2.76403163f },
+    { 4320.0f, 32161.4919f, 2.60621404f, 2.71843936f },
+    { 4340.0f, 32388.4643f, 3.10917968f, 2.67284708f },
+    { 4360.0f, 32540.4181f, 3.61214481f, 2.62725481f },
+    { 4380.0f, 32636.8683f, 4.11510384f, 2.58166253f },
+    { 4400.0f, 32694.358f, 4.61805169f, 2.53607026f },
+    { 4420.0f, 32726.0953f, 5.12098538f, 2.49047799f },
+    { 4440.0f, 32741.9798f, 5.62390521f, 2.44488571f },
+    { 4460.0f, 32748.9279f, 6.1268146f, 2.39929344f },
+    { 4480.0f, 32751.3945f, 0.346534652f, 2.35370116f },
+    { 4500.0f, 32751.9693f, 0.849443638f, 2.30810889f },
+    { 4520.0f, 32751.9613f, 1.35236427f, 2.26251661f },
+    { 4540.0f, 32751.8992f, 1.85530204f, 2.21692434f },
+    { 4560.0f, 32751.9072f, 2.35825977f, 2.17133207f },
+    { 4580.0f, 32751.9543f, 2.86123558f, 2.12573979f },
+    { 4600.0f, 32751.9891f, 3.36422419f, 2.08014752f },
+    { 4620.0f, 32751.9903f, 3.86721656f, 2.03455524f },
+    { 4640.0f, 32751.9685f, 4.37020277f, 1.98896297f },
+    { 4660.0f, 32751.9474f, 4.87317244f, 1.94337069f },
+    { 4680.0f, 32751.9429f, 5.37611964f, 1.89777842f },
+    { 4700.0f, 32751.9568f, 5.87904132f, 1.85218614f },
+    { 4720.0f, 32751.9779f, 0.0987543643f, 1.80659387f },
+    { 4740.0f, 32751.9924f, 0.60163603f, 1.7610016f },
+    { 4760.0f, 32751.9918f, 1.10451138f, 1.71540932f },
+    { 4780.0f, 32751.978f, 1.6073914f, 1.66981705f },
+    { 4800.0f, 32751.961f, 2.11028668f, 1.62422477f },
+    { 4820.0f, 32751.9518f, 2.61320409f, 1.5786325f },
+    { 4840.0f, 32751.9564f, 3.11614698f, 1.53304022f },
+    { 4860.0f, 32751.9719f, 3.61911366f, 1.48744795f },
+    { 4880.0f, 32751.9881f, 4.12209743f, 1.44185568f },
+    { 4900.0f, 32751.9937f, 4.62509044f, 1.3962634f },
+    { 4920.0f, 32751.9842f, 5.12808256f, 1.35067113f },
+    { 4940.0f, 32751.9639f, 5.63106513f, 1.30507885f },
+    { 4960.0f, 32751.9458f, 6.13403239f, 1.25948658f },
+    { 4980.0f, 32751.9434f, 0.353796514f, 1.2138943f },
+    { 5000.0f, 32751.9602f, 0.856729798f, 1.16830203f },
+    { 5020.0f, 32751.984f, 1.35965049f, 1.12270976f },
+    { 5040.0f, 32751.9934f, 1.86256455f, 1.07711748f },
+    { 5060.0f, 32751.9695f, 2.36547784f, 1.03152521f },
+    { 5080.0f, 32751.922f, 2.86839477f, 0.985932932f },
+    { 5100.0f, 32751.894f, 3.37131789f, 0.940340658f },
+    { 5120.0f, 32751.9342f, 3.87424826f, 0.894748384f },
+    { 5140.0f, 32751.9932f, 4.37718396f, 0.84915611f },
+    { 5160.0f, 32751.7178f, 4.88012356f, 0.803563835f },
+    { 5180.0f, 32750.1175f, 5.38306478f, 0.757971561f },
+    { 5200.0f, 32745.1055f, 5.88600668f, 0.712379286f },
+    { 5220.0f, 32732.9365f, 0.105763234f, 0.666787012f },
+    { 5240.0f, 32707.6049f, 0.608706501f, 0.621194738f },
+    { 5260.0f, 32660.2863f, 1.1116528f, 0.575602463f },
+    { 5280.0f, 32578.9297f, 1.61460255f, 0.530010189f },
+    { 5300.0f, 32448.1192f, 2.11755572f, 0.484417915f },
+    { 5320.0f, 32249.2921f, 2.62051107f, 0.438825641f },
+    { 5340.0f, 31961.3947f, 3.12346567f, 0.393233366f },
+    { 5360.0f, 31561.9652f, 3.62641602f, 0.347641092f },
+    { 5380.0f, 31028.6316f, 4.12935834f, 0.302048817f },
+    { 5400.0f, 30340.8731f, 4.63228996f, 0.256456543f },
+    { 5420.0f, 29481.93f, 5.13520906f, 0.210864269f },
+    { 5440.0f, 28440.6146f, 5.63811927f, 0.165271994f },
+    { 5460.0f, 27212.86f, 6.14101768f, 0.119679725f },
+    { 5480.0f, 25802.8193f, 0.360739738f, 0.0740874456f },
+    { 5497.5f, 24428.929f, 0.800881713f, 0.0341941028f },
+    { 5498.5f, 24346.9399f, 0.825834054f, 0.0319147092f },
+    { 5499.5f, 24263.9048f, 0.851223608f, 0.0296348237f },
+    { 5500.0f, 24222.196f, 0.863580108f, 0.0284952616f },
+    { 5500.5f, 24181.5474f, 0.876117994f, 0.0273554989f },
+    { 5501.5f, 24097.0578f, 0.901590604f, 0.0250755223f },
+    { 5502.5f, 24014.7296f, 0.92644056f, 0.0227962565f },
+    { 5503.5f, 23927.9945f, 0.952000689f, 0.0205161869f },
+    { 5504.5f, 23846.5893f, 0.9769018f, 0.0182368896f },
+    { 5505.5f, 23755.4506f, 1.00248722f, 0.0159568089f },
+    { 5506.5f, 23677.3929f, 1.02793821f, 0.0136769872f },
+    { 5507.5f, 23574.0246f, 1.0530709f, 0.011397493f },
+    { 5508.5f, 23508.2581f, 1.08238814f, 0.00911384292f },
+    { 5509.5f, 23342.2678f, 1.1021904f, 0.00684093762f },
+    { 5510.5f, 23274.7081f, 1.23392337f, 0.00684040484f },
+    { 5511.5f, 23207.1483f, 1.36565634f, 0.00683987206f },
+    { 5512.5f, 23139.5886f, 1.4973893f, 0.00683933928f },
+    { 5513.5f, 23072.0288f, 1.62912227f, 0.00683880649f },
+    { 5514.5f, 23004.4691f, 1.76085524f, 0.00683827371f },
+    { 5515.5f, 22936.9093f, 1.89258821f, 0.00683774093f },
+    { 5516.5f, 22813.627f, 1.87407207f, 0.00910754303f },
+    { 5517.5f, 22723.9609f, 1.83842648f, 0.0113982482f },
+    { 5518.5f, 22632.4472f, 1.81608271f, 0.0136743796f },
+    { 5519.5f, 22541.0229f, 1.78779506f, 0.0159573504f },
+    { 5520.0f, 22494.0908f, 1.7761014f, 0.0170961068f },
+    { 5520.5f, 22452.2489f, 1.76383898f, 0.0182355363f },
+    { 5521.5f, 22360.5422f, 1.73743745f, 0.0205164961f },
+    { 5522.5f, 22271.4833f, 1.71282704f, 0.0227954734f },
+    { 5523.5f, 22179.6272f, 1.68712012f, 0.0250756868f },
+    { 5524.5f, 22089.8142f, 1.66220991f, 0.027355019f },
+    { 5525.5f, 21997.7545f, 1.63681041f, 0.0296349006f },
+    { 5526.5f, 21907.1469f, 1.61175212f, 0.0319144064f },
+    { 5527.5f, 21814.8171f, 1.58650247f, 0.034194126f },
+    { 5540.0f, 20648.4343f, 1.27207117f, 0.0626893625f },
+    { 5560.0f, 18716.6943f, 0.769071891f, 0.108281653f },
+    { 5580.0f, 16739.3822f, 0.26606364f, 0.153873926f },
+    { 5600.0f, 14757.1979f, 6.04621847f, 0.199466201f },
+    { 5620.0f, 12810.4935f, 5.54318062f, 0.245058474f },
+    { 5640.0f, 10937.0178f, 5.04015209f, 0.290650749f },
+    { 5660.0f, 9170.12625f, 4.5371608f, 0.336243023f },
+    { 5680.0f, 7537.39221f, 4.0342377f, 0.381835298f },
+    { 5700.0f, 6059.72627f, 3.53141703f, 0.427427572f },
+    { 5720.0f, 4750.99573f, 3.02873167f, 0.473019846f },
+    { 5740.0f, 3618.09421f, 2.52620668f, 0.518612121f },
+    { 5760.0f, 2661.38829f, 2.02385037f, 0.564204395f },
+    { 5780.0f, 1875.43843f, 1.52163647f, 0.609796669f },
+    { 5800.0f, 1249.90118f, 1.01946835f, 0.655388944f },
+    { 5820.0f, 770.527533f, 0.517080572f, 0.700981218f },
+    { 5840.0f, 420.194571f, 0.0136883935f, 0.746573492f },
+    { 5860.0f, 179.927864f, 5.78918715f, 0.792165767f },
+    { 5880.0f, 29.927765f, 5.22887537f, 0.837758041f },
+    { 5900.0f, 49.8475628f, 1.70040122f, 0.883350315f },
+    { 5920.0f, 77.9727283f, 1.18335202f, 0.928942589f },
+    { 5940.0f, 71.8452512f, 0.682336418f, 0.974534864f },
+    { 5960.0f, 46.4050087f, 0.189194648f, 1.02012714f },
+    { 5980.0f, 13.8466253f, 6.02016373f, 1.06571941f },
+    { 6000.0f, 16.8075927f, 2.25755326f, 1.11131169f },
+    { 6020.0f, 39.4231912f, 1.79170372f, 1.15690396f },
+    { 6040.0f, 51.0831568f, 1.30120909f, 1.20249624f },
+    { 6060.0f, 51.3924109f, 0.808865257f, 1.24808851f },
+    { 6080.0f, 42.0294911f, 0.320550481f, 1.29368078f },
+    { 6100.0f, 26.0682374f, 6.1326941f, 1.33927306f },
+    { 6120.0f, 7.36067857f, 5.81884615f, 1.38486533f },
+    { 6140.0f, 11.1356782f, 1.75169246f, 1.43045762f },
+    { 6160.0f, 25.2963376f, 1.34816606f, 1.47604988f },
+    { 6180.0f, 33.6615595f, 0.870411387f, 1.52164216f },
+    { 6200.0f, 35.3906614f, 0.38188328f, 1.56723443f },
+    { 6220.0f, 30.9181777f, 6.1775361f, 1.6128267f },
+    { 6240.0f, 21.7051618f, 5.70388644f, 1.65841898f },
+    { 6260.0f, 9.92478221f, 5.30624958f, 1.70401125f },
+    { 6280.0f, 3.06766546f, 0.810816299f, 1.74960355f },
+    { 6300.0f, 12.8491543f, 0.822946322f, 1.7951958f },
+    { 6320.0f, 19.5888227f, 0.374554646f, 1.84078807f },
+    { 6340.0f, 22.0150565f, 6.17480614f, 1.88638035f },
+    { 6360.0f, 20.1119719f, 5.68593189f, 1.93197263f },
+    { 6380.0f, 14.6654933f, 5.2055458f, 1.9775649f },
+    { 6400.0f, 7.06334977f, 4.78226052f, 2.02315717f },
+    { 6420.0f, 1.62680269f, 0.245461841f, 2.06874945f },
+    { 6440.0f, 8.38814471f, 0.344606649f, 2.11434172f },
+    { 6460.0f, 13.1098267f, 6.17102078f, 2.15993399f },
+    { 6480.0f, 14.7455132f, 5.68021945f, 2.20552627f },
+    { 6500.0f, 13.1858306f, 5.18078912f, 2.25111855f },
+    { 6520.0f, 8.95636302f, 4.68037041f, 2.29671082f },
+    { 6540.0f, 3.07417955f, 4.19845348f, 2.3423031f },
+    { 6560.0f, 3.18339305f, 0.476274161f, 2.38789539f },
+    { 6580.0f, 8.51508915f, 6.27471737f, 2.43348764f },
+    { 6600.0f, 11.8815874f, 5.771418f, 2.47907992f },
+    { 6620.0f, 12.6739757f, 5.26548785f, 2.52467219f },
+    { 6640.0f, 10.8234798f, 4.75836951f, 2.57026446f },
+    { 6660.0f, 6.79333646f, 4.24835322f, 2.61585674f },
+    { 6680.0f, 1.46950618f, 3.69703138f, 2.66144902f },
+    { 6700.0f, 4.03966507f, 0.134397032f, 2.70704129f },
+    { 6720.0f, 8.6061546f, 5.90436811f, 2.75263356f },
+    { 6740.0f, 11.3365169f, 5.40217048f, 2.79822583f },
+    { 6760.0f, 11.724225f, 4.90484767f, 2.84381813f },
+    { 6780.0f, 9.74465152f, 4.41421248f, 2.88941039f },
+    { 6800.0f, 5.8470047f, 3.94224449f, 2.93500266f },
+    { 6820.0f, 5.06519869f, 4.9480521f, 2.98059493f },
+    { 6840.0f, 4.28339267f, 5.95385971f, 3.02618721f },
+    { 6860.0f, 8.46308218f, 5.50449825f, 3.07177948f },
+    { 6875.625f, 10.5728003f, 5.13264599f, 3.10739858f },
+    { 6876.625f, 10.6660776f, 5.10880793f, 3.10967809f },
+    { 6877.625f, 10.7533772f, 5.08475818f, 3.11195784f },
+    { 6878.625f, 10.8361863f, 5.06085498f, 3.11423741f },
+    { 6879.625f, 10.9123589f, 5.0368229f, 3.11651712f },
+    { 6880.0f, 10.9405893f, 5.02792373f, 3.11737188f },
+    { 6880.625f, 10.9847141f, 5.01276971f, 3.11879684f },
+    { 6881.625f, 11.0493348f, 4.9888581f, 3.12107641f },
+    { 6882.625f, 11.1114388f, 4.96432005f, 3.12335662f },
+    { 6883.625f, 11.1637962f, 4.94080281f, 3.1256357f },
+    { 6884.625f, 11.2164359f, 4.91466478f, 3.12791758f },
+    { 6885.625f, 11.2543721f, 4.89250246f, 3.13019492f },
+    { 6886.625f, 11.3004537f, 4.85876643f, 3.13248461f },
+    { 6887.625f, 11.31353f, 4.84314344f, 3.13475289f },
+    { 6888.625f, 11.3282971f, 4.82246974f, 3.13475298f },
+    { 6889.625f, 11.3430643f, 4.80179604f, 3.13475308f },
+    { 6890.625f, 11.3578314f, 4.78112234f, 3.13475317f },
+    { 6891.625f, 11.3725986f, 4.76044863f, 3.13475327f },
+    { 6892.625f, 11.3873657f, 4.73977493f, 3.13475336f },
+    { 6893.625f, 11.4021329f, 4.71910123f, 3.13475345f },
+    { 6894.625f, 11.4055795f, 4.73446913f, 3.13248567f },
+    { 6895.625f, 11.3873f, 4.76919665f, 3.13019478f },
+    { 6896.625f, 11.3739268f, 4.79075779f, 3.12791803f },
+    { 6897.625f, 11.3478934f, 4.81725303f, 3.1256356f },
+    { 6898.625f, 11.3213448f, 4.84034726f, 3.12335686f },
+    { 6899.625f, 11.2855941f, 4.86496826f, 3.12107635f },
+    { 6900.0f, 11.2725274f, 4.87341402f, 3.12022202f },
+    { 6900.625f, 11.247149f, 4.88853092f, 3.11879698f },
+    { 6901.625f, 11.2011001f, 4.91252774f, 3.11651709f },
+    { 6902.625f, 11.1512355f, 4.93623308f, 3.11423749f },
+    { 6903.625f, 11.0947389f, 4.9599684f, 3.11195783f },
+    { 6904.625f, 11.0338431f, 4.98368019f, 3.10967815f },
+    { 6905.625f, 10.9668577f, 5.0072733f, 3.10739857f },
+    { 6920.0f, 9.45120661f, 5.34268156f, 3.07462899f },
+    { 6940.0f, 5.89541699f, 5.7757778f, 3.02903672f },
+    { 6960.0f, 1.48300387f, 5.82267188f, 2.98344445f },
+    { 6980.0f, 3.56656071f, 3.97171769f, 2.93785218f },
+    { 7000.0f, 7.46821081f, 4.33593481f, 2.8922599f },
+    { 7020.0f, 9.93518725f, 4.79094669f, 2.84666763f },
+    { 7040.0f, 10.5384127f, 5.26364828f, 2.80107536f },
+    { 7060.0f, 9.24099173f, 5.74128969f, 2.75548308f },
+    { 7080.0f, 6.36355069f, 6.21617836f, 2.70989081f },
+    { 7100.0f, 2.5044513f, 0.369878948f, 2.66429853f },
+    { 7120.0f, 1.62812728f, 4.22239194f, 2.61870626f },
+    { 7140.0f, 5.23047617f, 4.62785331f, 2.57311398f },
+    { 7160.0f, 7.74027257f, 5.11709424f, 2.52752171f },
+    { 7180.0f, 8.78662031f, 5.62525317f, 2.48192943f },
+    { 7200.0f, 8.29692931f, 6.15369014f, 2.43633716f },
+    { 7220.0f, 6.48926479f, 0.437682851f, 2.39074489f },
+    { 7240.0f, 3.84951981f, 1.12250958f, 2.34515261f },
+    { 7260.0f, 1.54324803f, 2.5501033f, 2.29956033f },
+    { 7280.0f, 2.9247925f, 4.40226897f, 2.25396806f },
+    { 7300.0f, 5.01740861f, 5.19343684f, 2.20837579f },
+    { 7320.0f, 6.2871144f, 5.84406729f, 2.16278351f },
+    { 7340.0f, 6.56959026f, 0.207064863f, 2.11719124f },
+    { 7360.0f, 6.01073261f, 0.899638957f, 2.07159896f },
+    { 7380.0f, 4.98832644f, 1.69227989f, 2.02600669f },
+    { 7400.0f, 4.06927431f, 2.6449877f, 1.98041442f },
+    { 7420.0f, 3.78817388f, 3.72044067f, 1.93482214f },
+    { 7440.0f, 4.10162055f, 4.74248289f, 1.88922987f },
+    { 7460.0f, 4.536074f, 5.65860293f, 1.8436376f },
+    { 7480.0f, 4.83168278f, 0.243289954f, 1.79804532f },
+    { 7500.0f, 5.0021853f, 1.10461874f, 1.75245304f },
+    { 7520.0f, 5.13542414f, 1.96385224f, 1.70686078f },
+    { 7540.0f, 5.2253615f, 2.80830117f, 1.66126849f },
+    { 7560.0f, 5.16351549f, 3.63826116f, 1.61567622f },
+    { 7580.0f, 4.87138669f, 4.48044625f, 1.57008395f },
+    { 7600.0f, 4.44752984f, 5.38038551f, 1.52449167f },
+    { 7620.0f, 4.2104625f, 0.079248304f, 1.4788994f },
+    { 7640.0f, 4.4458259f, 1.07045129f, 1.43330712f },
+    { 7660.0f, 4.99108505f, 1.96542787f, 1.38771486f },
+    { 7680.0f, 5.3822633f, 2.75949435f, 1.34212258f },
+    { 7700.0f, 5.25061545f, 3.50743907f, 1.2965303f },
+    { 7720.0f, 4.49150661f, 4.28577568f, 1.25093802f },
+    { 7740.0f, 3.40766989f, 5.23498314f, 1.20534575f },
+    { 7760.0f, 3.02987252f, 0.221665402f, 1.15975348f },
+    { 7780.0f, 4.11436563f, 1.36807564f, 1.1141612f },
+    { 7800.0f, 5.60841479f, 2.18066872f, 1.06856893f },
+    { 7820.0f, 6.56272268f, 2.84146976f, 1.02297665f },
+    { 7840.0f, 6.51284234f, 3.44373527f, 0.977384381f },
+    { 7860.0f, 5.30155247f, 4.03577147f, 0.931792107f },
+    { 7880.0f, 3.06575443f, 4.70410729f, 0.88619983f },
+    { 7900.0f, 3.27757064f, 3.35413268f, 0.840607557f },
+    { 7920.0f, 3.48938685f, 2.00415806f, 0.795015284f },
+    { 7940.0f, 6.28366442f, 2.63144165f, 0.749423011f },
+    { 7960.0f, 8.15779809f, 3.16732097f, 0.703830733f },
+    { 7980.0f, 8.65715115f, 3.67533279f, 0.658238461f },
+    { 8000.0f, 7.59135771f, 4.16750286f, 0.612646186f },
+    { 8020.0f, 5.06721287f, 4.63958822f, 0.567053912f },
+    { 8040.0f, 1.49752408f, 4.98292039f, 0.521461635f },
+    { 8060.0f, 2.58432358f, 2.65360707f, 0.475869363f },
+    { 8080.0f, 6.29944877f, 3.06831564f, 0.430277092f },
+    { 8100.0f, 8.99110167f, 3.5366325f, 0.384684815f },
+    { 8120.0f, 10.0891861f, 4.01259962f, 0.33909254f },
+    { 8140.0f, 9.31296027f, 4.48787017f, 0.293500272f },
+    { 8160.0f, 6.73662771f, 4.95258124f, 0.247907992f },
+    { 8180.0f, 2.80292995f, 5.34337351f, 0.202315703f },
+    { 8200.0f, 1.90320486f, 3.09475561f, 0.156723445f },
+    { 8220.0f, 6.26077229f, 3.41633843f, 0.111131167f },
+    { 8240.0f, 9.5668761f, 3.88308649f, 0.0655389091f },
+    { 8253.75f, 10.8452257f, 4.2166878f, 0.0341940762f },
+    { 8254.75f, 10.9013693f, 4.24104902f, 0.0319145892f },
+    { 8255.75f, 10.9516029f, 4.26570029f, 0.0296348045f },
+    { 8256.75f, 10.9974141f, 4.29012958f, 0.0273553016f },
+    { 8257.75f, 11.0366918f, 4.3148327f, 0.0250755191f },
+    { 8258.75f, 11.0721946f, 4.33943106f, 0.0227958978f },
+    { 8259.75f, 11.1000899f, 4.36409956f, 0.0205162216f },
+    { 8260.0f, 11.1077676f, 4.37074646f, 0.0199457819f },
+    { 8260.75f, 11.1256184f, 4.38915198f, 0.0182361808f },
+    { 8261.75f, 11.1412887f, 4.41355297f, 0.0159569028f },
+    { 8262.75f, 11.1576696f, 4.44008057f, 0.0136753928f },
+    { 8263.75f, 11.1585785f, 4.46331154f, 0.0113976659f },
+    { 8264.75f, 11.169073f, 4.49696548f, 0.0091089201f },
+    { 8265.75f, 11.1416369f, 4.51375047f, 0.00684004592f },
+    { 8266.75f, 11.1224508f, 4.55610436f, 0.00683985752f },
+    { 8267.75f, 11.1032648f, 4.59845825f, 0.00683966912f },
+    { 8268.75f, 11.0840788f, 4.64081214f, 0.00683948071f },
+    { 8269.75f, 11.0648928f, 4.68316603f, 0.00683929231f },
+    { 8270.75f, 11.0457067f, 4.72551992f, 0.0068391039f },
+    { 8271.75f, 11.0265207f, 4.76787381f, 0.0068389155f },
+    { 8272.75f, 10.9893818f, 4.75138087f, 0.00910670456f },
+    { 8273.75f, 10.9371266f, 4.71530049f, 0.011397934f },
+    { 8274.75f, 10.887705f, 4.69279891f, 0.0136744795f },
+    { 8275.75f, 10.8271964f, 4.66498125f, 0.0159570965f },
+    { 8276.75f, 10.7656452f, 4.64081618f, 0.018235709f },
+    { 8277.75f, 10.6954769f, 4.61484675f, 0.0205163333f },
+    { 8278.75f, 10.6224729f, 4.59007408f, 0.0227956283f },
+    { 8279.75f, 10.5422039f, 4.56469472f, 0.025075578f },
+    { 8280.0f, 10.5221666f, 4.55837198f, 0.025645538f },
+    { 8280.75f, 10.4581674f, 4.53965447f, 0.0273551349f },
+    { 8281.75f, 10.3676878f, 4.51445845f, 0.0296348322f },
+    { 8282.75f, 10.2728847f, 4.48928003f, 0.0319144917f },
+    { 8283.75f, 10.1722268f, 4.46412936f, 0.0341940847f },
+    { 8300.0f, 7.86035797f, 4.04982873f, 0.0712379231f },
+    { 8320.0f, 3.5920981f, 3.50001973f, 0.116830187f },
+    { 8340.0f, 1.547705f, 0.154545914f, 0.162422476f },
+    { 8360.0f, 6.44723295f, 5.76952295f, 0.20801475f },
+    { 8380.0f, 10.2333602f, 5.23749465f, 0.253607021f },
+    { 8400.0f, 12.121049f, 4.71086087f, 0.2991993f },
+    { 8420.0f, 11.7119056f, 4.17518136f, 0.34479157f },
+    { 8440.0f, 9.07053282f, 3.61106447f, 0.390383845f },
+    { 8460.0f, 4.77152148f, 2.92690895f, 0.435976124f },
+    { 8480.0f, 1.76161149f, 0.684788432f, 0.48156839f },
+    { 8500.0f, 6.18278381f, 5.60219028f, 0.527160672f },
+    { 8520.0f, 10.0973042f, 4.96370926f, 0.572752946f },
+    { 8540.0f, 12.1021858f, 4.38472908f, 0.618345221f },
+    { 8560.0f, 11.7655412f, 3.80580907f, 0.663937497f },
+    { 8580.0f, 9.18723869f, 3.18694797f, 0.70952977f },
+    { 8600.0f, 5.0947977f, 2.3855662f, 0.755122044f },
+    { 8620.0f, 2.83994819f, 0.463158172f, 0.800714306f },
+    { 8640.0f, 6.69740405f, 5.39342296f, 0.846306592f },
+    { 8660.0f, 10.4291995f, 4.6868008f, 0.891898871f },
+    { 8680.0f, 12.3066081f, 4.07350716f, 0.937491141f },
+    { 8700.0f, 11.8522009f, 3.47199345f, 0.983083415f },
+    { 8720.0f, 9.1669006f, 2.83386552f, 1.02867569f },
+    { 8740.0f, 5.00415536f, 2.00036721f, 1.07426797f },
+    { 8760.0f, 3.03465984f, 0.0234501347f, 1.11986024f },
+    { 8780.0f, 7.14488245f, 5.01537337f, 1.16545251f },
+    { 8800.0f, 11.090499f, 4.31465663f, 1.21104479f },
+    { 8820.0f, 13.2393169f, 3.70676822f, 1.25663706f },
+    { 8840.0f, 13.0983954f, 3.12011972f, 1.30222934f },
+    { 8860.0f, 10.694612f, 2.52478443f, 1.3478216f },
+    { 8880.0f, 6.53014793f, 1.86184903f, 1.39341388f },
+    { 8900.0f, 2.02161739f, 0.520358111f, 1.43900616f },
+    { 8920.0f, 4.76716266f, 4.55986844f, 1.48459843f },
+    { 8940.0f, 9.16576673f, 3.82498415f, 1.53019071f },
+    { 8960.0f, 12.1030402f, 3.22533981f, 1.57578298f },
+    { 8980.0f, 13.0471188f, 2.65530474f, 1.62137525f },
+    { 9000.0f, 11.9167509f, 2.09310031f, 1.66696753f },
+    { 9020.0f, 9.00364731f, 1.52605194f, 1.71255981f },
+    { 9040.0f, 4.89480136f, 0.920914556f, 1.75815208f },
+    { 9060.0f, 4.49821059f, 2.09334308f, 1.80374435f },
+    { 9080.0f, 4.10161982f, 3.2657716f, 1.84933663f },
+    { 9100.0f, 7.44742662f, 2.65596918f, 1.8949289f },
+    { 9120.0f, 9.43525636f, 2.09972666f, 1.94052118f },
+    { 9140.0f, 9.88133759f, 1.55974137f, 1.98611345f },
+    { 9160.0f, 8.87657055f, 1.03113151f, 2.03170573f },
+    { 9180.0f, 6.73245363f, 0.517888352f, 2.077298f },
+    { 9200.0f, 3.90452668f, 0.0430623847f, 2.12289027f },
+    { 9220.0f, 2.94566641f, 0.920643489f, 2.16848255f },
+    { 9240.0f, 1.98680614f, 1.79822459f, 2.21407482f },
+    { 9260.0f, 4.12481458f, 1.4223338f, 2.25966711f },
+    { 9280.0f, 5.48239522f, 0.966133659f, 2.30525937f },
+    { 9300.0f, 6.00107504f, 0.510024068f, 2.35085165f },
+    { 9320.0f, 5.7706013f, 0.0728604354f, 2.39644391f },
+    { 9340.0f, 4.97221002f, 5.95272869f, 2.4420362f },
+    { 9360.0f, 3.82772733f, 5.60733573f, 2.48762847f },
+    { 9380.0f, 2.57023423f, 5.38200257f, 2.53322074f },
+    { 9400.0f, 1.53693839f, 5.49281043f, 2.57881302f },
+    { 9420.0f, 1.51135886f, 6.06229762f, 2.62440529f },
+    { 9440.0f, 2.42684918f, 6.17155031f, 2.66999756f },
+    { 9460.0f, 3.458485f, 5.94997583f, 2.71558985f },
+    { 9480.0f, 4.28418631f, 5.61231341f, 2.76118211f },
+    { 9500.0f, 4.71569645f, 5.22099318f, 2.80677439f },
+    { 9520.0f, 4.61027227f, 4.80157332f, 2.85236666f },
+    { 9540.0f, 3.89631259f, 4.37360724f, 2.89795894f },
+    { 9560.0f, 2.60968171f, 3.97519616f, 2.94355121f },
+    { 9580.0f, 1.93750995f, 4.72713471f, 2.98914349f },
+    { 9600.0f, 1.26533818f, 5.47907326f, 3.03473576f },
+    { 9620.0f, 3.00684694f, 5.24815112f, 3.08032804f },
+    { 9631.875f, 3.87906169f, 4.99325284f, 3.10739857f },
+    { 9632.875f, 3.9435749f, 4.970628f, 3.10967815f },
+    { 9633.875f, 4.00625383f, 4.9477966f, 3.11195783f },
+    { 9634.875f, 4.06763739f, 4.92482986f, 3.1142375f },
+    { 9635.875f, 4.12690932f, 4.90183227f, 3.11651709f },
+    { 9636.875f, 4.18511962f, 4.87841999f, 3.118797f },
+    { 9637.875f, 4.24078637f, 4.85540956f, 3.12107635f },
+    { 9638.875f, 4.29575707f, 4.83121203f, 3.12335687f },
+    { 9639.875f, 4.3475273f, 4.80852631f, 3.12563559f },
+    { 9640.0f, 4.35386071f, 4.80448003f, 3.12592177f },
+    { 9640.875f, 4.39943527f, 4.78229256f, 3.12791805f },
+    { 9641.875f, 4.44676477f, 4.76099701f, 3.13019478f },
+    { 9642.875f, 4.49624251f, 4.72642345f, 3.13248571f },
+    { 9643.875f, 4.53772881f, 4.71115484f, 3.1347535f },
+    { 9644.875f, 4.5752003f, 4.73454006f, 3.13475339f },
+    { 9645.875f, 4.61267178f, 4.75792527f, 3.13475328f },
+    { 9646.875f, 4.65014326f, 4.78131049f, 3.13475318f },
+    { 9647.875f, 4.68761475f, 4.80469571f, 3.13475307f },
+    { 9648.875f, 4.72508623f, 4.82808092f, 3.13475296f },
+    { 9649.875f, 4.76255771f, 4.85146614f, 3.13475286f },
+    { 9650.875f, 4.80220053f, 4.86734807f, 3.13248451f },
+    { 9651.875f, 4.82791498f, 4.90125492f, 3.13019493f },
+    { 9652.875f, 4.85751844f, 4.92376066f, 3.12791755f },
+    { 9653.875f, 4.88095452f, 4.95020056f, 3.12563571f },
+    { 9654.875f, 4.90478449f, 4.97414001f, 3.1233566f },
+    { 9655.875f, 4.92459579f, 4.99907601f, 3.12107641f },
+    { 9656.875f, 4.94353567f, 5.02346247f, 3.11879682f },
+    { 9657.875f, 4.95933221f, 5.04798697f, 3.11651713f },
+    { 9658.875f, 4.97359559f, 5.07257852f, 3.11423739f },
+    { 9659.875f, 4.98508295f, 5.09703196f, 3.11195784f },
+    { 9660.0f, 4.98644669f, 5.10024899f, 3.11167272f },
+    { 9660.875f, 4.99477543f, 5.12168628f, 3.10967809f },
+    { 9661.875f, 5.0019195f, 5.14614465f, 3.10739858f },
+    { 9680.0f, 4.73864951f, 5.59466291f, 3.06608045f },
+    { 9700.0f, 3.60934197f, 6.08997072f, 3.02048817f },
+    { 9720.0f, 1.76950369f, 0.275285085f, 2.9748959f },
+    { 9740.0f, 2.23563724f, 5.56478302f, 2.92930362f },
+    { 9760.0f, 2.70177079f, 4.57109565f, 2.88371135f },
+    { 9780.0f, 4.48354884f, 5.06103065f, 2.83811908f },
+    { 9800.0f, 5.46831669f, 5.56335501f, 2.7925268f },
+    { 9820.0f, 5.44110621f, 6.06584313f, 2.74693453f },
+    { 9840.0f, 4.37821894f, 0.278345172f, 2.70134225f },
+    { 9860.0f, 2.45938486f, 0.745721935f, 2.65574998f },
+    { 9880.0f, 2.46980513f, 6.04223685f, 2.6101577f },
+    { 9900.0f, 2.48022539f, 5.05556647f, 2.56456543f },
+    { 9920.0f, 4.55274604f, 5.509113f, 2.51897316f },
+    { 9940.0f, 5.82321483f, 5.98094239f, 2.47338088f },
+    { 9960.0f, 6.05464711f, 0.161228632f, 2.42778861f },
+    { 9980.0f, 5.21956334f, 0.597222849f, 2.38219633f },
+    { 10000.0f, 3.52176999f, 0.95206261f, 2.33660406f },
+    { 10020.0f, 1.54752411f, 0.876290692f, 2.29101179f },
+    { 10040.0f, 1.91882551f, 6.0497745f, 2.24541949f },
+    { 10060.0f, 3.82353932f, 6.137373f, 2.19982724f },
+    { 10080.0f, 5.20717993f, 0.191228636f, 2.15423496f },
+    { 10100.0f, 5.71867476f, 0.557276123f, 2.10864269f },
+    { 10120.0f, 5.33107391f, 0.892560964f, 2.06305041f },
+    { 10140.0f, 4.27613816f, 1.13019333f, 2.01745814f },
+    { 10160.0f, 3.13242787f, 1.13178204f, 1.97186585f },
+    { 10180.0f, 2.91565886f, 0.849134829f, 1.92627358f },
+    { 10200.0f, 3.79402923f, 0.746194961f, 1.88068132f },
+    { 10220.0f, 4.77362072f, 0.895242561f, 1.83508904f },
+    { 10240.0f, 5.2906264f, 1.13655282f, 1.78949677f },
+    { 10260.0f, 5.21119255f, 1.38414931f, 1.74390449f },
+    { 10280.0f, 4.65079125f, 1.57930825f, 1.69831222f },
+    { 10300.0f, 3.93321781f, 1.65869043f, 1.65271994f },
+    { 10320.0f, 3.55388016f, 1.5934109f, 1.60712767f },
+    { 10340.0f, 3.8377008f, 1.51486114f, 1.56153538f },
+    { 10360.0f, 4.52291742f, 1.57108081f, 1.51594312f },
+    { 10380.0f, 5.14812035f, 1.74818528f, 1.47035085f },
+    { 10400.0f, 5.40906756f, 1.99058227f, 1.42475857f },
+    { 10420.0f, 5.15832151f, 2.2558433f, 1.37916629f },
+    { 10440.0f, 4.380218f, 2.50011411f, 1.33357402f },
+    { 10460.0f, 3.23625851f, 2.63437838f, 1.28798174f },
+    { 10480.0f, 2.3078187f, 2.43781474f, 1.24238949f },
+    { 10500.0f, 2.6979675f, 2.04530283f, 1.1967972f },
+    { 10520.0f, 3.99956244f, 2.07203072f, 1.15120491f },
+    { 10540.0f, 5.17190881f, 2.34712877f, 1.10561266f },
+    { 10560.0f, 5.72660537f, 2.71987332f, 1.06002038f },
+    { 10580.0f, 5.4446957f, 3.137942f, 1.01442811f },
+    { 10600.0f, 4.29401287f, 3.57701453f, 0.96883583f },
+    { 10620.0f, 2.4168127f, 4.00536092f, 0.923243555f },
+    { 10640.0f, 2.3703738f, 3.0275433f, 0.877651281f },
+    { 10660.0f, 2.3239349f, 2.04972567f, 0.832059006f },
+    { 10680.0f, 4.36552186f, 2.51162477f, 0.786466732f },
+    { 10700.0f, 5.71172118f, 3.01866824f, 0.740874458f },
+    { 10720.0f, 6.12021605f, 3.54662686f, 0.695282184f },
+    { 10740.0f, 5.5149543f, 4.09622546f, 0.649689909f },
+    { 10760.0f, 4.00305138f, 4.68685207f, 0.604097642f },
+    { 10780.0f, 1.89486308f, 5.44925586f, 0.558505361f },
+    { 10800.0f, 1.06538381f, 1.64737286f, 0.512913086f },
+    { 10820.0f, 3.19354953f, 2.74939846f, 0.467320808f },
+    { 10840.0f, 4.99073198f, 3.39062958f, 0.421728535f },
+    { 10860.0f, 5.9862715f, 3.97679581f, 0.376136263f },
+    { 10880.0f, 6.00676723f, 4.54884437f, 0.330543984f },
+    { 10900.0f, 5.05869561f, 5.11987179f, 0.284951714f },
+    { 10920.0f, 3.31692678f, 5.70665126f, 0.23935944f },
+    { 10940.0f, 1.10798125f, 0.158611326f, 0.193767165f },
+    { 10960.0f, 1.31033792f, 3.33804455f, 0.148174901f },
+    { 10980.0f, 3.33666219f, 4.01984557f, 0.102582619f },
+    { 11000.0f, 4.74746311f, 4.5793007f, 0.0569903017f },
+    { 11010.0f, 5.14219375f, 4.84656567f, 0.0341941525f },
+    { 11011.0f, 5.16940215f, 4.87307069f, 0.0319143828f },
+    { 11012.0f, 5.19400978f, 4.89922129f, 0.029634943f },
+    { 11013.0f, 5.2166297f, 4.92576579f, 0.0273549971f },
+    { 11014.0f, 5.23662644f, 4.95161552f, 0.0250757508f },
+    { 11015.0f, 5.25468484f, 4.97832534f, 0.0227954738f },
+    { 11016.0f, 5.27007158f, 5.00374605f, 0.0205165858f },
+    { 11017.0f, 5.28349797f, 5.03099717f, 0.0182355793f },
+    { 11018.0f, 5.2945113f, 5.05562491f, 0.0159574768f },
+    { 11019.0f, 5.30313881f, 5.08443818f, 0.0136746551f },
+    { 11020.0f, 5.31098716f, 5.10747515f, 0.0113983841f },
+    { 11021.0f, 5.31397269f, 5.14226321f, 0.00910906911f },
+    { 11022.0f, 5.32804175f, 5.16278761f, 0.00683727316f },
+    { 11023.0f, 5.31992266f, 5.25645337f, 0.00448672803f },
+    { 11024.0f, 6.98859618f, 1.57079614f, 1.60888704e-10f },
+    { 11025.0f, 9.19615008f, 4.71238882f, 1.60888704e-10f },
+};
+
+static const TPqfWidebandPoint PqfWidebandTable4[] = {
+    { 1.0f, 6.79214998f, 0.321699646f, 0.00166107819f },
+    { 2.0f, 6.49349781f, 6.13629701f, 0.00465621083f },
+    { 3.0f, 6.49767521f, 6.20877825f, 0.0068381897f },
+    { 4.0f, 6.4804763f, 6.17653448f, 0.00912944574f },
+    { 5.0f, 6.4732662f, 6.16307402f, 0.0113983474f },
+    { 6.0f, 6.45669383f, 6.13722072f, 0.0136805369f },
+    { 7.0f, 6.44236466f, 6.11583397f, 0.0159575956f },
+    { 8.0f, 6.42234304f, 6.09142108f, 0.0182379139f },
+    { 9.0f, 6.40221937f, 6.06828241f, 0.0205167767f },
+    { 10.0f, 6.37800393f, 6.04429993f, 0.0227965325f },
+    { 11.0f, 6.35262254f, 6.02060376f, 0.0250759541f },
+    { 12.0f, 6.32386717f, 5.99674326f, 0.0273555225f },
+    { 13.0f, 6.29338272f, 5.97281685f, 0.0296351427f },
+    { 14.0f, 6.25997994f, 5.94897077f, 0.0319146446f },
+    { 15.0f, 6.22462145f, 5.9249401f, 0.0341943349f },
+    { 20.0f, 6.01130843f, 5.80485517f, 0.0455922527f },
+    { 40.0f, 4.61359076f, 5.31172479f, 0.0911845557f },
+    { 60.0f, 2.53034775f, 4.75193639f, 0.136776822f },
+    { 80.0f, 2.54709122f, 6.05501722f, 0.182369097f },
+    { 100.0f, 2.56383468f, 1.07491273f, 0.227961372f },
+    { 120.0f, 4.64818298f, 0.500700144f, 0.273553647f },
+    { 140.0f, 6.0254712f, 6.26297893f, 0.319145921f },
+    { 160.0f, 6.46008871f, 5.74183367f, 0.364738193f },
+    { 180.0f, 5.8851699f, 5.1983026f, 0.410330469f },
+    { 200.0f, 4.42583766f, 4.59343664f, 0.455922743f },
+    { 220.0f, 2.47467061f, 3.76454877f, 0.501515007f },
+    { 240.0f, 1.61194545f, 1.98094685f, 0.547107292f },
+    { 260.0f, 3.29167458f, 0.693169571f, 0.592699569f },
+    { 280.0f, 5.01625689f, 6.24287255f, 0.638291841f },
+    { 300.0f, 6.03744917f, 5.59623249f, 0.683884115f },
+    { 320.0f, 6.18483222f, 4.94530363f, 0.729476388f },
+    { 340.0f, 5.54571283f, 4.23987182f, 0.775068658f },
+    { 360.0f, 4.46740068f, 3.40985326f, 0.820660938f },
+    { 380.0f, 3.61149388f, 2.36210368f, 0.86625322f },
+    { 400.0f, 3.68269497f, 1.1907564f, 0.911845487f },
+    { 420.0f, 4.45319866f, 0.170833277f, 0.957437761f },
+    { 440.0f, 5.21498292f, 5.57835487f, 1.00303004f },
+    { 460.0f, 5.64602992f, 4.74892081f, 1.04862231f },
+    { 480.0f, 5.76542208f, 3.90907237f, 1.09421458f },
+    { 500.0f, 5.75017214f, 3.03971272f, 1.13980686f },
+    { 520.0f, 5.75062565f, 2.1521982f, 1.18539912f },
+    { 540.0f, 5.76257607f, 1.26748989f, 1.23099141f },
+    { 560.0f, 5.67473312f, 0.387765329f, 1.27658368f },
+    { 580.0f, 5.4352259f, 5.77310121f, 1.32217596f },
+    { 600.0f, 5.17089485f, 4.8276769f, 1.36776823f },
+    { 620.0f, 5.14299582f, 3.83826695f, 1.4133605f },
+    { 640.0f, 5.48804013f, 2.86395747f, 1.45895277f },
+    { 660.0f, 6.02421261f, 1.95618673f, 1.50454505f },
+    { 680.0f, 6.42803319f, 1.10920696f, 1.55013732f },
+    { 700.0f, 6.48078572f, 0.287492074f, 1.5957296f },
+    { 720.0f, 6.16308105f, 5.73488712f, 1.64132188f },
+    { 740.0f, 5.64930922f, 4.85115989f, 1.68691415f },
+    { 760.0f, 5.21630542f, 3.90792612f, 1.73250643f },
+    { 780.0f, 5.04384223f, 2.93685483f, 1.7780987f },
+    { 800.0f, 5.05659723f, 1.98478869f, 1.82369097f },
+    { 820.0f, 5.05509674f, 1.0585646f, 1.86928326f },
+    { 840.0f, 4.96537274f, 0.129428299f, 1.91487552f },
+    { 860.0f, 4.91450362f, 5.45951578f, 1.96046779f },
+    { 880.0f, 5.0708635f, 4.50677809f, 2.00606008f },
+    { 900.0f, 5.38422288f, 3.60550411f, 2.05165235f },
+    { 920.0f, 5.56544228f, 2.77272162f, 2.09724462f },
+    { 940.0f, 5.31112092f, 1.98141866f, 2.1428369f },
+    { 960.0f, 4.49621974f, 1.17329332f, 2.18842917f },
+    { 980.0f, 3.32404518f, 0.224731064f, 2.23402144f },
+    { 1000.0f, 2.65126813f, 5.20913317f, 2.27961372f },
+    { 1020.0f, 3.4562834f, 3.92369565f, 2.32520599f },
+    { 1040.0f, 4.8423993f, 3.02225053f, 2.37079826f },
+    { 1060.0f, 5.82133943f, 2.30128826f, 2.41639055f },
+    { 1080.0f, 5.95951244f, 1.64554651f, 2.46198281f },
+    { 1100.0f, 5.1333766f, 1.00089188f, 2.50757509f },
+    { 1120.0f, 3.4794565f, 0.29812577f, 2.55316736f },
+    { 1140.0f, 1.54804612f, 5.45868789f, 2.59875964f },
+    { 1160.0f, 1.95459434f, 3.34717626f, 2.64435192f },
+    { 1180.0f, 3.88311748f, 2.43084104f, 2.68994417f },
+    { 1200.0f, 5.27758707f, 1.77945832f, 2.73553646f },
+    { 1220.0f, 5.73191859f, 1.18065125f, 2.78112873f },
+    { 1240.0f, 5.15102008f, 0.586972452f, 2.82672101f },
+    { 1260.0f, 3.67043685f, 6.23751343f, 2.87231328f },
+    { 1280.0f, 1.68867547f, 5.36042194f, 2.91790556f },
+    { 1300.0f, 1.32589046f, 3.03205893f, 2.96349783f },
+    { 1320.0f, 3.21185695f, 1.99935062f, 3.00909011f },
+    { 1340.0f, 4.69134384f, 1.34974205f, 3.05468238f },
+    { 1360.0f, 5.34667795f, 0.756064593f, 3.10027468f },
+    { 1363.125f, 5.36549524f, 0.664695222f, 3.10739833f },
+    { 1364.125f, 5.36652181f, 0.635251247f, 3.10967815f },
+    { 1365.125f, 5.36545935f, 0.606210066f, 3.11195751f },
+    { 1366.125f, 5.3617534f, 0.576748318f, 3.11423734f },
+    { 1367.125f, 5.35618154f, 0.547717092f, 3.11651667f },
+    { 1368.125f, 5.34762702f, 0.518277702f, 3.11879647f },
+    { 1369.125f, 5.33778678f, 0.489237387f, 3.1210758f },
+    { 1370.125f, 5.3242002f, 0.460011705f, 3.12335535f },
+    { 1371.125f, 5.31057349f, 0.430770979f, 3.1256349f },
+    { 1372.125f, 5.2915405f, 0.402571184f, 3.12791337f },
+    { 1373.125f, 5.275561f, 0.372366869f, 3.13019409f },
+    { 1374.125f, 5.24939182f, 0.350025246f, 3.13246656f },
+    { 1375.125f, 5.23980284f, 0.31361418f, 3.13475539f },
+    { 1376.125f, 5.2053749f, 0.763152273f, 3.13475508f },
+    { 1377.125f, 5.17094696f, 1.21269037f, 3.13475477f },
+    { 1378.125f, 5.13651903f, 1.66222846f, 3.13475446f },
+    { 1379.125f, 5.10209109f, 2.11176655f, 3.13475415f },
+    { 1380.0f, 5.07196664f, 2.50511238f, 3.13475387f },
+    { 1380.125f, 5.06766315f, 2.56130465f, 3.13475383f },
+    { 1381.125f, 5.03323522f, 3.01084274f, 3.13475352f },
+    { 1382.125f, 4.99509051f, 3.0487166f, 3.1324624f },
+    { 1383.125f, 4.95552178f, 3.06736004f, 3.13019453f },
+    { 1384.125f, 4.91127406f, 3.09993417f, 3.12791165f },
+    { 1385.125f, 4.86691807f, 3.12695918f, 3.12563521f },
+    { 1386.125f, 4.81890955f, 3.15799595f, 3.12335449f },
+    { 1387.125f, 4.77024725f, 3.18718402f, 3.12107597f },
+    { 1388.125f, 4.71856183f, 3.21782012f, 3.11879597f },
+    { 1389.125f, 4.66580967f, 3.24786119f, 3.11651675f },
+    { 1390.125f, 4.61055766f, 3.27847149f, 3.11423704f },
+    { 1391.125f, 4.55396342f, 3.3090174f, 3.11195754f },
+    { 1392.125f, 4.49518196f, 3.33977859f, 3.10967795f },
+    { 1393.125f, 4.43495653f, 3.37069747f, 3.10739833f },
+    { 1400.0f, 3.9748472f, 3.58776486f, 3.0917261f },
+    { 1420.0f, 2.31022335f, 4.32293294f, 3.04613383f },
+    { 1440.0f, 2.24965261f, 2.87347252f, 3.00054155f },
+    { 1460.0f, 2.18908187f, 1.4240121f, 2.95494927f },
+    { 1480.0f, 3.78822011f, 2.17244527f, 2.90935701f },
+    { 1500.0f, 4.89546906f, 2.78937367f, 2.86376473f },
+    { 1520.0f, 5.34124412f, 3.37136957f, 2.81817245f },
+    { 1540.0f, 5.09423506f, 3.93935807f, 2.77258018f },
+    { 1560.0f, 4.21422299f, 4.50107029f, 2.72698791f },
+    { 1580.0f, 2.82499351f, 5.06531927f, 2.68139564f },
+    { 1600.0f, 1.09600709f, 5.69388295f, 2.63580336f },
+    { 1620.0f, 1.88665421f, 4.52846229f, 2.59021109f },
+    { 1640.0f, 2.67730134f, 3.36304163f, 2.54461882f },
+    { 1660.0f, 4.30253288f, 3.8789631f, 2.49902654f },
+    { 1680.0f, 5.51845044f, 4.36309426f, 2.45343426f },
+    { 1700.0f, 6.17283485f, 4.82370249f, 2.40784199f },
+    { 1720.0f, 6.15620478f, 5.25960329f, 2.3622497f },
+    { 1740.0f, 5.41734046f, 5.6608067f, 2.31665744f },
+    { 1760.0f, 3.99463313f, 5.98852349f, 2.27106516f },
+    { 1780.0f, 2.16423719f, 6.02937357f, 2.22547286f },
+    { 1800.0f, 1.87985937f, 5.05153893f, 2.17988062f },
+    { 1820.0f, 4.19741612f, 4.90394626f, 2.13428834f },
+    { 1840.0f, 6.72081809f, 5.18722194f, 2.08869607f },
+    { 1860.0f, 8.72244604f, 5.55565741f, 2.04310379f },
+    { 1880.0f, 9.76096945f, 5.94821769f, 1.99751152f },
+    { 1900.0f, 9.52694367f, 0.057525477f, 1.95191924f },
+    { 1920.0f, 7.90801182f, 0.421751328f, 1.90632697f },
+    { 1940.0f, 5.1105327f, 0.668073134f, 1.8607347f },
+    { 1960.0f, 2.48764329f, 0.219377343f, 1.81514242f },
+    { 1980.0f, 4.68290179f, 5.73633744f, 1.76955015f },
+    { 2000.0f, 8.51658189f, 5.91864582f, 1.72395787f },
+    { 2020.0f, 11.5601329f, 6.27601352f, 1.6783656f },
+    { 2040.0f, 13.032067f, 0.391306759f, 1.63277332f },
+    { 2060.0f, 12.542163f, 0.793188147f, 1.58718105f },
+    { 2080.0f, 10.0909629f, 1.16423295f, 1.54158878f },
+    { 2100.0f, 6.18494445f, 1.39959365f, 1.4959965f },
+    { 2120.0f, 3.03978593f, 0.838058017f, 1.45040422f },
+    { 2140.0f, 6.01946057f, 0.195702572f, 1.40481195f },
+    { 2160.0f, 10.1506667f, 0.414615905f, 1.35921968f },
+    { 2180.0f, 12.8493318f, 0.782031055f, 1.3136274f },
+    { 2200.0f, 13.4074941f, 1.18013532f, 1.26803513f },
+    { 2220.0f, 11.6850072f, 1.56584993f, 1.22244286f },
+    { 2240.0f, 8.09038354f, 1.87121482f, 1.17685058f },
+    { 2260.0f, 4.01210822f, 1.76049079f, 1.13125831f },
+    { 2280.0f, 4.68752485f, 0.8529026f, 1.08566603f },
+    { 2300.0f, 8.72209118f, 0.900208617f, 1.04007376f },
+    { 2320.0f, 11.6662341f, 1.23571858f, 0.994481485f },
+    { 2340.0f, 12.4872012f, 1.63044322f, 0.94888921f },
+    { 2360.0f, 10.9595542f, 2.02534257f, 0.903296934f },
+    { 2380.0f, 7.44558338f, 2.35167025f, 0.857704661f },
+    { 2400.0f, 3.26932363f, 2.22129084f, 0.812112387f },
+    { 2420.0f, 4.43898859f, 1.14107777f, 0.766520108f },
+    { 2440.0f, 8.6979905f, 1.27031276f, 0.720927839f },
+    { 2460.0f, 11.6662152f, 1.64590616f, 0.675335563f },
+    { 2480.0f, 12.4515461f, 2.07221297f, 0.629743288f },
+    { 2500.0f, 10.8478124f, 2.50556325f, 0.584151015f },
+    { 2520.0f, 7.18130928f, 2.90225587f, 0.538558741f },
+    { 2540.0f, 2.42851283f, 2.93721465f, 0.492966479f },
+    { 2560.0f, 3.81274899f, 1.311936f, 0.44737419f },
+    { 2580.0f, 8.42181108f, 1.57439572f, 0.401781918f },
+    { 2600.0f, 11.5450009f, 2.00684879f, 0.356189643f },
+    { 2620.0f, 12.4849676f, 2.47146153f, 0.310597368f },
+    { 2640.0f, 11.0706643f, 2.94466398f, 0.265005094f },
+    { 2660.0f, 7.60624591f, 3.41104281f, 0.219412821f },
+    { 2680.0f, 2.80941613f, 3.79184237f, 0.173820545f },
+    { 2700.0f, 2.5100981f, 1.51489636f, 0.128228271f },
+    { 2720.0f, 7.10419733f, 1.88363444f, 0.0826359865f },
+    { 2740.0f, 10.2525231f, 2.35867109f, 0.0370437895f },
+    { 2741.25f, 10.3858699f, 2.38902643f, 0.0341943117f },
+    { 2742.25f, 10.4864176f, 2.41356888f, 0.0319144801f },
+    { 2743.25f, 10.5820914f, 2.43770708f, 0.0296351309f },
+    { 2744.25f, 10.6719204f, 2.46234989f, 0.0273552407f },
+    { 2745.25f, 10.7572536f, 2.48645911f, 0.0250759848f },
+    { 2746.25f, 10.8360288f, 2.51119881f, 0.0227960341f },
+    { 2747.25f, 10.9112718f, 2.53527565f, 0.0205168597f },
+    { 2748.25f, 10.9784348f, 2.55998857f, 0.0182369656f },
+    { 2749.25f, 11.0444834f, 2.58410696f, 0.0159577766f },
+    { 2750.25f, 11.0987659f, 2.60826885f, 0.0136784517f },
+    { 2751.25f, 11.1593118f, 2.63291325f, 0.011398634f },
+    { 2752.25f, 11.1963976f, 2.65312809f, 0.00912327435f },
+    { 2753.25f, 11.2754333f, 2.68308991f, 0.00683686438f },
+    { 2754.25f, 11.2875431f, 2.28696458f, 0.00683737586f },
+    { 2755.25f, 11.2996528f, 1.89083925f, 0.00683788734f },
+    { 2756.25f, 11.3117626f, 1.49471391f, 0.00683839881f },
+    { 2757.25f, 11.3238723f, 1.09858858f, 0.00683891029f },
+    { 2758.25f, 11.3359821f, 0.702463248f, 0.00683942177f },
+    { 2759.25f, 11.3480918f, 0.306337916f, 0.00683993325f },
+    { 2760.0f, 11.3547008f, 0.286859261f, 0.00855257443f },
+    { 2760.25f, 11.3669622f, 0.275003134f, 0.00912938357f },
+    { 2761.25f, 11.3638032f, 0.260816991f, 0.0113978947f },
+    { 2762.25f, 11.3558483f, 0.233289959f, 0.0136809945f },
+    { 2763.25f, 11.3422809f, 0.211705291f, 0.015957245f },
+    { 2764.25f, 11.321692f, 0.185777665f, 0.0182382813f },
+    { 2765.25f, 11.2968982f, 0.162273988f, 0.0205165561f },
+    { 2766.25f, 11.2651448f, 0.136979007f, 0.0227967998f },
+    { 2767.25f, 11.2292301f, 0.11277221f, 0.0250758126f },
+    { 2768.25f, 11.1866302f, 0.087751192f, 0.0273557112f },
+    { 2769.25f, 11.139671f, 0.0632139016f, 0.0296350572f },
+    { 2770.25f, 11.0864447f, 0.0383292394f, 0.0319147758f },
+    { 2771.25f, 11.0286117f, 0.0136245326f, 0.0341942855f },
+    { 2780.0f, 10.2978492f, 6.07956244f, 0.0541408541f },
+    { 2800.0f, 7.30445329f, 5.58191129f, 0.0997331012f },
+    { 2820.0f, 3.0181699f, 5.08710068f, 0.145325374f },
+    { 2840.0f, 1.70669717f, 1.42085841f, 0.190917655f },
+    { 2860.0f, 5.96097249f, 0.932276776f, 0.23650992f },
+    { 2880.0f, 8.96031451f, 0.435710506f, 0.282102198f },
+    { 2900.0f, 10.1888808f, 6.22460875f, 0.327694472f },
+    { 2920.0f, 9.48855577f, 5.73685995f, 0.373286746f },
+    { 2940.0f, 7.07516075f, 5.26613636f, 0.41887902f },
+    { 2960.0f, 3.49306887f, 4.86785548f, 0.464471306f },
+    { 2980.0f, 3.98055658f, 5.78490232f, 0.510063574f },
+    { 3000.0f, 4.46804428f, 0.418763846f, 0.555655843f },
+    { 3020.0f, 7.24281659f, 6.2822236f, 0.601248114f },
+    { 3040.0f, 8.60470216f, 5.83612489f, 0.646840389f },
+    { 3060.0f, 8.40160585f, 5.40265795f, 0.692432667f },
+    { 3080.0f, 6.81763406f, 5.01563943f, 0.738024941f },
+    { 3100.0f, 4.38774994f, 4.77310818f, 0.783617215f },
+    { 3120.0f, 2.44202168f, 5.097723f, 0.82920949f },
+    { 3140.0f, 3.43584992f, 5.67397929f, 0.874801759f },
+    { 3160.0f, 5.33948397f, 5.55587882f, 0.92039404f },
+    { 3180.0f, 6.49894468f, 5.25671739f, 0.965986313f },
+    { 3200.0f, 6.63317388f, 4.94050332f, 1.01157859f },
+    { 3220.0f, 5.91063779f, 4.68039779f, 1.05717086f },
+    { 3240.0f, 4.85177929f, 4.55520361f, 1.10276314f },
+    { 3260.0f, 4.26312407f, 4.60808026f, 1.1483554f },
+    { 3280.0f, 4.58943781f, 4.66755508f, 1.19394769f },
+    { 3300.0f, 5.27956657f, 4.57315667f, 1.23953996f },
+    { 3320.0f, 5.67760381f, 4.37859363f, 1.28513223f },
+    { 3340.0f, 5.56342567f, 4.1691076f, 1.33072451f },
+    { 3360.0f, 5.08536041f, 4.01097801f, 1.37631678f },
+    { 3380.0f, 4.63374909f, 3.94286907f, 1.42190905f },
+    { 3400.0f, 4.57516045f, 3.92552888f, 1.46750133f },
+    { 3420.0f, 4.8787239f, 3.86242957f, 1.5130936f },
+    { 3440.0f, 5.2058436f, 3.72576027f, 1.55868588f },
+    { 3460.0f, 5.31489863f, 3.55392936f, 1.60427815f },
+    { 3480.0f, 5.2056431f, 3.39030556f, 1.64987043f },
+    { 3500.0f, 5.04178166f, 3.25377037f, 1.6954627f },
+    { 3520.0f, 4.96050381f, 3.12624527f, 1.74105498f },
+    { 3540.0f, 4.90096616f, 2.97539659f, 1.78664725f },
+    { 3560.0f, 4.6567178f, 2.80054108f, 1.83223952f },
+    { 3580.0f, 4.10184095f, 2.65163542f, 1.87783179f },
+    { 3600.0f, 3.43121378f, 2.63323604f, 1.92342407f },
+    { 3620.0f, 3.3255687f, 2.79552928f, 1.96901634f },
+    { 3640.0f, 4.21693071f, 2.85925408f, 2.01460862f },
+    { 3660.0f, 5.47753708f, 2.68231311f, 2.0602009f },
+    { 3680.0f, 6.36644738f, 2.36449314f, 2.10579317f },
+    { 3700.0f, 6.42445449f, 1.98213565f, 2.15138545f },
+    { 3720.0f, 5.44226285f, 1.58125801f, 2.19697772f },
+    { 3740.0f, 3.46914611f, 1.2311061f, 2.24256999f },
+    { 3760.0f, 1.12631314f, 1.55887307f, 2.28816228f },
+    { 3780.0f, 2.81424427f, 2.75289962f, 2.33375454f },
+    { 3800.0f, 5.64479534f, 2.44473022f, 2.37934682f },
+    { 3820.0f, 7.75883154f, 1.99680803f, 2.42493909f },
+    { 3840.0f, 8.63630668f, 1.51425017f, 2.47053137f },
+    { 3860.0f, 8.00326668f, 1.01779575f, 2.51612364f },
+    { 3880.0f, 5.86363125f, 0.51554361f, 2.56171592f },
+    { 3900.0f, 2.51508046f, 0.018841839f, 2.60730819f },
+    { 3920.0f, 1.49155434f, 2.58988126f, 2.65290046f },
+    { 3940.0f, 5.43425514f, 2.10335832f, 2.69849274f },
+    { 3960.0f, 8.56400167f, 1.59317274f, 2.74408501f },
+    { 3980.0f, 10.2411584f, 1.08040311f, 2.78967729f },
+    { 4000.0f, 10.0726517f, 0.56737897f, 2.83526956f },
+    { 4020.0f, 8.00475945f, 0.0555826505f, 2.88086183f },
+    { 4040.0f, 4.35292297f, 5.83261307f, 2.92645411f },
+    { 4060.0f, 4.63963991f, 0.592672955f, 2.97204639f },
+    { 4080.0f, 4.92635686f, 1.63591815f, 3.01763866f },
+    { 4100.0f, 8.78875007f, 1.13098556f, 3.06323094f },
+    { 4119.375f, 11.0092262f, 0.638871483f, 3.10739833f },
+    { 4120.0f, 11.0498839f, 0.622973965f, 3.10882311f },
+    { 4120.375f, 11.0730092f, 0.613300477f, 3.10967813f },
+    { 4121.375f, 11.1319074f, 0.588120532f, 3.1119575f },
+    { 4122.375f, 11.1847591f, 0.562533021f, 3.11423733f },
+    { 4123.375f, 11.2332788f, 0.537383773f, 3.11651666f },
+    { 4124.375f, 11.2748991f, 0.511838556f, 3.11879646f },
+    { 4125.375f, 11.3132184f, 0.486703152f, 3.1210758f },
+    { 4126.375f, 11.3430114f, 0.461398389f, 3.12335537f },
+    { 4127.375f, 11.3720277f, 0.436120925f, 3.1256349f },
+    { 4128.375f, 11.3888857f, 0.411844649f, 3.12791343f },
+    { 4129.375f, 11.4117536f, 0.385705271f, 3.13019408f },
+    { 4130.375f, 11.4116323f, 0.367101184f, 3.13246688f },
+    { 4131.375f, 11.4482304f, 0.334918922f, 3.13475546f },
+    { 4132.375f, 11.4255917f, 0.773092351f, 3.1347551f },
+    { 4133.375f, 11.402953f, 1.21126578f, 3.13475474f },
+    { 4134.375f, 11.3803143f, 1.64943921f, 3.13475438f },
+    { 4135.375f, 11.3576756f, 2.08761264f, 3.13475402f },
+    { 4136.375f, 11.3350369f, 2.52578607f, 3.13475366f },
+    { 4137.375f, 11.3123982f, 2.96395949f, 3.1347533f },
+    { 4138.375f, 11.283211f, 2.99706849f, 3.13246249f },
+    { 4139.375f, 11.2449912f, 3.01121701f, 3.13019461f },
+    { 4140.0f, 11.2179515f, 3.02710343f, 3.12876952f },
+    { 4140.375f, 11.1972194f, 3.03926901f, 3.1279116f },
+    { 4141.375f, 11.146926f, 3.06148982f, 3.12563528f },
+    { 4142.375f, 11.0879495f, 3.08783934f, 3.12335442f },
+    { 4143.375f, 11.0259143f, 3.11202373f, 3.12107602f },
+    { 4144.375f, 10.9563098f, 3.13775158f, 3.11879591f },
+    { 4145.375f, 10.8829449f, 3.16260413f, 3.11651677f },
+    { 4146.375f, 10.8027309f, 3.18804787f, 3.11423699f },
+    { 4147.375f, 10.7182508f, 3.21316316f, 3.11195756f },
+    { 4148.375f, 10.6274496f, 3.23846302f, 3.10967792f },
+    { 4149.375f, 10.5320702f, 3.2637001f, 3.10739834f },
+    { 4160.0f, 9.19855597f, 3.5315723f, 3.08317751f },
+    { 4180.0f, 5.3376325f, 4.02882701f, 3.03758529f },
+    { 4200.0f, 5.05915471f, 2.98933385f, 2.99199301f },
+    { 4220.0f, 4.78067693f, 1.94984068f, 2.94640073f },
+    { 4240.0f, 9.03533431f, 2.44174102f, 2.90080846f },
+    { 4260.0f, 11.5336837f, 2.94165529f, 2.85521618f },
+    { 4280.0f, 11.7286596f, 3.44231209f, 2.80962391f },
+    { 4300.0f, 9.52766348f, 3.94161546f, 2.76403163f },
+    { 4320.0f, 5.32569859f, 4.4352037f, 2.71843936f },
+    { 4340.0f, 5.43925442f, 3.38072692f, 2.67284708f },
+    { 4360.0f, 5.55281025f, 2.32625014f, 2.62725481f },
+    { 4380.0f, 10.00616f, 2.81859255f, 2.58166253f },
+    { 4400.0f, 12.4633851f, 3.31582303f, 2.53607026f },
+    { 4420.0f, 12.3438636f, 3.81460805f, 2.49047798f },
+    { 4440.0f, 9.58022116f, 4.31564354f, 2.44488571f },
+    { 4460.0f, 4.65275016f, 4.8270528f, 2.39929343f },
+    { 4480.0f, 1.4947134f, 2.07656179f, 2.35370116f },
+    { 4500.0f, 7.59293651f, 2.64058775f, 2.30810889f },
+    { 4520.0f, 12.3461997f, 3.14725887f, 2.26251661f },
+    { 4540.0f, 14.644929f, 3.65280693f, 2.21692434f },
+    { 4560.0f, 13.8239806f, 4.1646166f, 2.17133206f },
+    { 4580.0f, 9.82546236f, 4.69951339f, 2.12573978f },
+    { 4600.0f, 3.32710078f, 5.42311755f, 2.08014752f },
+    { 4620.0f, 5.03629282f, 2.22944602f, 2.03455524f },
+    { 4640.0f, 12.9025753f, 2.86466791f, 1.98896296f },
+    { 4660.0f, 19.0366257f, 3.39623799f, 1.9433707f },
+    { 4680.0f, 21.926708f, 3.91384557f, 1.89777842f },
+    { 4700.0f, 20.6154409f, 4.43391049f, 1.85218615f },
+    { 4720.0f, 14.9027671f, 4.9768755f, 1.80659387f },
+    { 4740.0f, 5.5727196f, 5.69945058f, 1.7610016f },
+    { 4760.0f, 6.90057805f, 2.44080357f, 1.71540932f },
+    { 4780.0f, 18.9039394f, 3.12130828f, 1.66981704f },
+    { 4800.0f, 28.9841468f, 3.6616862f, 1.62422477f },
+    { 4820.0f, 34.812111f, 4.18182455f, 1.5786325f },
+    { 4840.0f, 34.7191643f, 4.69858579f, 1.53304022f },
+    { 4860.0f, 27.9877691f, 5.22216778f, 1.48744795f },
+    { 4880.0f, 15.1156178f, 5.78727272f, 1.44185568f },
+    { 4900.0f, 3.03448955f, 2.36275163f, 1.3962634f },
+    { 4920.0f, 21.4840468f, 3.44738244f, 1.35067113f },
+    { 4940.0f, 38.5172429f, 3.99324308f, 1.30507885f },
+    { 4960.0f, 49.8568686f, 4.51311803f, 1.25948658f },
+    { 4980.0f, 52.189582f, 5.02708639f, 1.2138943f },
+    { 5000.0f, 43.4221018f, 5.54131283f, 1.16830203f },
+    { 5020.0f, 23.3710628f, 6.06830774f, 1.12270976f },
+    { 5040.0f, 5.76856106f, 3.23277982f, 1.07711748f },
+    { 5060.0f, 38.5210411f, 3.87711712f, 1.03152521f },
+    { 5080.0f, 66.7697082f, 4.39323549f, 0.985932932f },
+    { 5100.0f, 79.0254914f, 4.8998857f, 0.940340658f },
+    { 5120.0f, 60.9965822f, 5.39590967f, 0.894748385f },
+    { 5140.0f, 4.61892686f, 3.27398977f, 0.849156107f },
+    { 5160.0f, 134.740148f, 3.31493175f, 0.803563835f },
+    { 5180.0f, 350.576746f, 3.81019329f, 0.757971561f },
+    { 5200.0f, 671.563894f, 4.31213588f, 0.712379287f },
+    { 5220.0f, 1116.98264f, 4.81548724f, 0.666787012f },
+    { 5240.0f, 1704.51319f, 5.3191757f, 0.621194738f },
+    { 5260.0f, 2449.22013f, 5.82285959f, 0.575602464f },
+    { 5280.0f, 3362.51917f, 0.0432288266f, 0.530010189f },
+    { 5300.0f, 4451.16531f, 0.546615617f, 0.484417915f },
+    { 5320.0f, 5716.32008f, 1.04983768f, 0.43882564f },
+    { 5340.0f, 7152.77526f, 1.55291751f, 0.393233366f },
+    { 5360.0f, 8748.43064f, 2.05588812f, 0.347641092f },
+    { 5380.0f, 10484.1185f, 2.55878419f, 0.302048817f },
+    { 5400.0f, 12333.8689f, 3.06163845f, 0.256456544f },
+    { 5420.0f, 14265.6613f, 3.56448012f, 0.210864269f },
+    { 5440.0f, 16242.6888f, 4.06732845f, 0.165271995f },
+    { 5460.0f, 18225.0785f, 4.57020464f, 0.119679715f },
+    { 5480.0f, 20171.9485f, 5.07310154f, 0.0740874458f },
+    { 5497.5f, 21815.4984f, 5.51306926f, 0.0341943086f },
+    { 5498.5f, 21907.0021f, 5.53840977f, 0.0319144749f },
+    { 5499.5f, 21998.8374f, 5.56331332f, 0.0296351328f },
+    { 5500.0f, 22044.7004f, 5.57610324f, 0.0284950814f },
+    { 5500.5f, 22089.4424f, 5.58871201f, 0.0273552303f },
+    { 5501.5f, 22181.3803f, 5.61353284f, 0.0250759794f },
+    { 5502.5f, 22270.7045f, 5.63897623f, 0.0227960177f },
+    { 5503.5f, 22363.4991f, 5.66371012f, 0.0205168594f },
+    { 5504.5f, 22450.6807f, 5.68910215f, 0.0182369297f },
+    { 5505.5f, 22546.4175f, 5.71381227f, 0.0159577811f },
+    { 5506.5f, 22629.1045f, 5.73865427f, 0.0136783768f },
+    { 5507.5f, 22735.4207f, 5.76382132f, 0.0113986376f },
+    { 5508.5f, 22804.9324f, 5.78481724f, 0.00912305456f },
+    { 5509.5f, 22971.4375f, 5.81519284f, 0.0068368436f },
+    { 5510.5f, 23039.1574f, 5.42174636f, 0.00683736265f },
+    { 5511.5f, 23106.8772f, 5.02829987f, 0.00683788171f },
+    { 5512.5f, 23174.5971f, 4.63485339f, 0.00683840077f },
+    { 5513.5f, 23242.3169f, 4.24140691f, 0.00683891983f },
+    { 5514.5f, 23310.0368f, 3.84796043f, 0.00683943889f },
+    { 5515.5f, 23377.7566f, 3.45451395f, 0.00683995795f },
+    { 5516.5f, 23499.6094f, 3.42278635f, 0.00912933086f },
+    { 5517.5f, 23585.9353f, 3.40811333f, 0.0113978893f },
+    { 5518.5f, 23673.9291f, 3.38016057f, 0.0136809864f },
+    { 5519.5f, 23761.1385f, 3.35815481f, 0.0159572419f },
+    { 5520.0f, 23805.8126f, 3.34470211f, 0.0170980977f },
+    { 5520.5f, 23844.9297f, 3.33181491f, 0.0182382841f },
+    { 5521.5f, 23931.1591f, 3.30792203f, 0.0205165508f },
+    { 5522.5f, 24013.8911f, 3.2822366f, 0.0227968012f },
+    { 5523.5f, 24098.9623f, 3.25764806f, 0.0250758151f },
+    { 5524.5f, 24181.1407f, 3.23226244f, 0.0273557104f },
+    { 5525.5f, 24265.0992f, 3.20736613f, 0.0296350562f },
+    { 5526.5f, 24346.779f, 3.18212888f, 0.0319147775f },
+    { 5527.5f, 24429.6919f, 3.15708233f, 0.0341942855f },
+    { 5540.0f, 25423.1126f, 2.84280463f, 0.062689392f },
+    { 5560.0f, 26877.1136f, 2.33984038f, 0.10828165f },
+    { 5580.0f, 28151.1353f, 1.83685674f, 0.153873926f },
+    { 5600.0f, 29238.9882f, 1.33388119f, 0.199466199f },
+    { 5620.0f, 30142.7314f, 0.83091652f, 0.245058475f },
+    { 5640.0f, 30871.904f, 0.327967849f, 0.290650749f },
+    { 5660.0f, 31442.0352f, 6.10821831f, 0.336243023f },
+    { 5680.0f, 31872.8831f, 5.60529536f, 0.381835297f },
+    { 5700.0f, 32186.5334f, 5.10237923f, 0.427427572f },
+    { 5720.0f, 32405.5765f, 4.599466f, 0.473019846f },
+    { 5740.0f, 32551.5392f, 4.0965508f, 0.51861212f },
+    { 5760.0f, 32643.6841f, 3.59363104f, 0.564204395f },
+    { 5780.0f, 32698.2515f, 3.09070546f, 0.609796669f },
+    { 5800.0f, 32728.1315f, 2.58777421f, 0.655388944f },
+    { 5820.0f, 32742.9268f, 2.08483796f, 0.700981218f },
+    { 5840.0f, 32749.2989f, 1.58189773f, 0.746573492f },
+    { 5860.0f, 32751.5019f, 1.07895383f, 0.792165767f },
+    { 5880.0f, 32751.9813f, 0.576006062f, 0.837758041f },
+    { 5900.0f, 32751.9549f, 0.0730536306f, 0.883350315f },
+    { 5920.0f, 32751.8981f, 5.85328083f, 0.92894259f },
+    { 5940.0f, 32751.912f, 5.35031693f, 0.974534864f },
+    { 5960.0f, 32751.96f, 4.84734841f, 1.02012714f },
+    { 5980.0f, 32751.9917f, 4.34437866f, 1.06571941f },
+    { 6000.0f, 32751.9899f, 3.84141217f, 1.11131169f },
+    { 6020.0f, 32751.9674f, 3.33845444f, 1.15690396f },
+    { 6040.0f, 32751.9472f, 2.83551068f, 1.20249624f },
+    { 6060.0f, 32751.9446f, 2.33258384f, 1.24808851f },
+    { 6080.0f, 32751.9598f, 1.82967474f, 1.29368078f },
+    { 6100.0f, 32751.9809f, 1.32678021f, 1.33927306f },
+    { 6120.0f, 32751.9942f, 0.8238936f, 1.38486533f },
+    { 6140.0f, 32751.9921f, 0.321006648f, 1.43045761f },
+    { 6160.0f, 32751.9776f, 6.10129525f, 1.47604988f },
+    { 6180.0f, 32751.9607f, 5.59838048f, 1.52164216f },
+    { 6200.0f, 32751.9527f, 5.09544265f, 1.56723443f },
+    { 6220.0f, 32751.9587f, 4.59248111f, 1.6128267f },
+    { 6240.0f, 32751.9747f, 4.08949968f, 1.65841898f },
+    { 6260.0f, 32751.9904f, 3.58650582f, 1.70401125f },
+    { 6280.0f, 32751.995f, 3.08350982f, 1.74960353f },
+    { 6300.0f, 32751.9835f, 2.58052145f, 1.7951958f },
+    { 6320.0f, 32751.9631f, 2.07754954f, 1.84078808f },
+    { 6340.0f, 32751.946f, 1.57459867f, 1.88638035f },
+    { 6360.0f, 32751.9455f, 1.0716695f, 1.93197262f },
+    { 6380.0f, 32751.9635f, 0.568757744f, 1.9775649f },
+    { 6400.0f, 32751.9872f, 0.0658563293f, 2.02315717f },
+    { 6420.0f, 32751.9936f, 5.8461418f, 2.06874945f },
+    { 6440.0f, 32751.9669f, 5.34323518f, 2.11434172f },
+    { 6460.0f, 32751.9189f, 4.84031571f, 2.159934f },
+    { 6480.0f, 32751.8956f, 4.33738078f, 2.20552627f },
+    { 6500.0f, 32751.9426f, 3.83443098f, 2.25111855f },
+    { 6520.0f, 32751.9922f, 3.33147119f, 2.29671082f },
+    { 6540.0f, 32751.6479f, 2.82850692f, 2.34230309f },
+    { 6560.0f, 32749.8376f, 2.32554493f, 2.38789537f },
+    { 6580.0f, 32744.3442f, 1.82259041f, 2.43348764f },
+    { 6600.0f, 32731.2364f, 1.31964624f, 2.47907992f },
+    { 6620.0f, 32704.2661f, 0.816712735f, 2.52467219f },
+    { 6640.0f, 32654.3203f, 0.313786709f, 2.57026447f },
+    { 6660.0f, 32569.0336f, 6.09404982f, 2.61585674f },
+    { 6680.0f, 32432.6798f, 5.59112697f, 2.66144901f },
+    { 6700.0f, 32226.4284f, 5.08819884f, 2.70704129f },
+    { 6720.0f, 31929.0391f, 4.58526373f, 2.75263356f },
+    { 6740.0f, 31517.9932f, 4.08232064f, 2.79822584f },
+    { 6760.0f, 30971.0088f, 3.57937158f, 2.84381811f },
+    { 6780.0f, 30267.8414f, 3.07641808f, 2.88941039f },
+    { 6800.0f, 29392.1693f, 2.57346407f, 2.93500266f },
+    { 6820.0f, 28333.4294f, 2.07051042f, 2.98059494f },
+    { 6840.0f, 27088.2707f, 1.56755817f, 3.02618721f },
+    { 6860.0f, 25661.7431f, 1.06461574f, 3.07177948f },
+    { 6875.625f, 24429.8451f, 0.671803948f, 3.10739833f },
+    { 6876.625f, 24347.4036f, 0.646487087f, 3.10967814f },
+    { 6877.625f, 24265.5559f, 0.621561586f, 3.11195751f },
+    { 6878.625f, 24181.9311f, 0.596217268f, 3.11423735f },
+    { 6879.625f, 24100.084f, 0.571344061f, 3.11651667f },
+    { 6880.0f, 24067.5182f, 0.561607553f, 3.11737187f },
+    { 6880.625f, 24014.8953f, 0.546016081f, 3.1187965f },
+    { 6881.625f, 23933.8369f, 0.521169769f, 3.1210758f },
+    { 6882.625f, 23846.2222f, 0.496028102f, 3.12335546f },
+    { 6883.625f, 23767.9943f, 0.471077434f, 3.12563489f },
+    { 6884.625f, 23675.6353f, 0.446843285f, 3.12791364f },
+    { 6885.625f, 23607.3238f, 0.421130278f, 3.13019406f },
+    { 6886.625f, 23501.9035f, 0.402099321f, 3.13246756f },
+    { 6887.625f, 23487.1845f, 0.370525452f, 3.13475557f },
+    { 6888.625f, 23384.4208f, 0.796576614f, 3.13475516f },
+    { 6889.625f, 23281.6572f, 1.22262778f, 3.13475475f },
+    { 6890.625f, 23178.8936f, 1.64867894f, 3.13475435f },
+    { 6891.625f, 23076.13f, 2.0747301f, 3.13475394f },
+    { 6892.625f, 22973.3664f, 2.50078126f, 3.13475353f },
+    { 6893.625f, 22870.6027f, 2.92683243f, 3.13475313f },
+    { 6894.625f, 22801.2606f, 2.95947194f, 3.13246263f },
+    { 6895.625f, 22716.8442f, 2.97353701f, 3.13019465f },
+    { 6896.625f, 22626.8899f, 3.00143754f, 3.12791159f },
+    { 6897.625f, 22540.8642f, 3.02344303f, 3.12563532f },
+    { 6898.625f, 22449.1874f, 3.049673f, 3.12335439f },
+    { 6899.625f, 22361.5176f, 3.07363622f, 3.12107604f },
+    { 6900.0f, 22326.3516f, 3.08374721f, 3.12022041f },
+    { 6900.625f, 22269.6357f, 3.09922902f, 3.11879589f },
+    { 6901.625f, 22180.6564f, 3.12388451f, 3.1165168f },
+    { 6902.625f, 22088.6544f, 3.14920017f, 3.11423698f },
+    { 6903.625f, 21998.6137f, 3.17414902f, 3.11195757f },
+    { 6904.625f, 21906.4141f, 3.1993352f, 3.1096779f },
+    { 6905.625f, 21815.4812f, 3.22441976f, 3.10739835f },
+    { 6920.0f, 20470.362f, 3.58578737f, 3.07462901f },
+    { 6940.0f, 18532.6591f, 4.08872632f, 3.02903672f },
+    { 6960.0f, 16553.1231f, 4.59165611f, 2.98344445f },
+    { 6980.0f, 14572.578f, 5.09458757f, 2.93785218f },
+    { 7000.0f, 12631.1888f, 5.59751002f, 2.8922599f },
+    { 7020.0f, 10766.3708f, 6.10041936f, 2.84666763f },
+    { 7040.0f, 9010.98327f, 0.320125548f, 2.80107535f },
+    { 7060.0f, 7392.00664f, 0.822995815f, 2.75548308f },
+    { 7080.0f, 5929.69944f, 1.32584872f, 2.70989081f },
+    { 7100.0f, 4637.26531f, 1.82869677f, 2.66429853f },
+    { 7120.0f, 3520.962f, 2.33157257f, 2.61870626f },
+    { 7140.0f, 2580.57729f, 2.83453965f, 2.57311398f },
+    { 7160.0f, 1810.17195f, 3.33771689f, 2.52752171f },
+    { 7180.0f, 1198.99412f, 3.84132891f, 2.48192943f },
+    { 7200.0f, 732.483505f, 4.34584529f, 2.43633716f },
+    { 7220.0f, 393.303181f, 4.85247594f, 2.39074489f },
+    { 7240.0f, 162.359632f, 5.36609726f, 2.34515261f },
+    { 7260.0f, 19.8914566f, 5.98428176f, 2.29956034f },
+    { 7280.0f, 54.351126f, 3.17590216f, 2.25396806f },
+    { 7300.0f, 78.5409859f, 3.70271791f, 2.20837579f },
+    { 7320.0f, 69.9997053f, 4.22098208f, 2.16278351f },
+    { 7340.0f, 43.4412026f, 4.75229791f, 2.11719124f },
+    { 7360.0f, 10.9379947f, 5.43299038f, 2.07159897f },
+    { 7380.0f, 19.5318109f, 2.443762f, 2.02600669f },
+    { 7400.0f, 41.0873329f, 3.02202253f, 1.98041442f },
+    { 7420.0f, 51.5953729f, 3.54899343f, 1.93482214f },
+    { 7440.0f, 50.8449536f, 4.06943422f, 1.88922987f },
+    { 7460.0f, 40.6766645f, 4.59291476f, 1.84363759f },
+    { 7480.0f, 24.2602615f, 5.13441636f, 1.79804532f },
+    { 7500.0f, 5.49931284f, 5.88462556f, 1.75245304f },
+    { 7520.0f, 12.6919315f, 2.82489508f, 1.70686077f },
+    { 7540.0f, 26.3774502f, 3.41028087f, 1.66126849f },
+    { 7560.0f, 34.1158289f, 3.94593015f, 1.61567622f },
+    { 7580.0f, 35.2188127f, 4.47523607f, 1.57008395f },
+    { 7600.0f, 30.2361895f, 5.00788213f, 1.52449167f },
+    { 7620.0f, 20.7066909f, 5.5561628f, 1.4788994f },
+    { 7640.0f, 8.83332932f, 6.18706135f, 1.43330712f },
+    { 7660.0f, 3.73250327f, 2.93033651f, 1.38771485f },
+    { 7680.0f, 13.4518785f, 3.79101131f, 1.34212258f },
+    { 7700.0f, 19.840117f, 4.36457174f, 1.2965303f },
+    { 7720.0f, 21.9215927f, 4.91651132f, 1.25093803f },
+    { 7740.0f, 19.7744406f, 5.47262882f, 1.20534575f },
+    { 7760.0f, 14.2594561f, 6.05706511f, 1.15975348f },
+    { 7780.0f, 6.88688994f, 0.494777112f, 1.11416121f },
+    { 7800.0f, 2.83388862f, 2.8199045f, 1.06856893f },
+    { 7820.0f, 8.69148187f, 4.08261832f, 1.02297666f },
+    { 7840.0f, 13.0227353f, 4.72632133f, 0.977384381f },
+    { 7860.0f, 14.397744f, 5.31230415f, 0.931792107f },
+    { 7880.0f, 12.7398188f, 5.90042528f, 0.886199836f },
+    { 7900.0f, 8.65660405f, 0.263186443f, 0.840607558f },
+    { 7920.0f, 3.61440925f, 1.28904122f, 0.795015284f },
+    { 7940.0f, 4.25163068f, 3.54278627f, 0.74942301f },
+    { 7960.0f, 8.75842357f, 4.43248361f, 0.70383073f },
+    { 7980.0f, 11.6774023f, 5.05749999f, 0.658238461f },
+    { 8000.0f, 12.1759359f, 5.63567652f, 0.612646186f },
+    { 8020.0f, 10.1998557f, 6.2131311f, 0.567053906f },
+    { 8040.0f, 6.26002044f, 0.565900401f, 0.521461637f },
+    { 8060.0f, 1.7980239f, 1.89366307f, 0.475869352f },
+    { 8080.0f, 4.61677199f, 4.16736696f, 0.430277088f },
+    { 8100.0f, 8.7397137f, 4.85772128f, 0.384684815f },
+    { 8120.0f, 11.1403563f, 5.42462564f, 0.33909254f },
+    { 8140.0f, 11.2937689f, 5.96402164f, 0.29350027f },
+    { 8160.0f, 9.19901827f, 0.214735611f, 0.247907991f },
+    { 8180.0f, 5.31504602f, 0.769305213f, 0.202315709f },
+    { 8200.0f, 4.92369575f, 5.88942868f, 0.156723439f },
+    { 8220.0f, 4.53234548f, 4.72636684f, 0.11113117f },
+    { 8240.0f, 8.4891818f, 5.2810484f, 0.0655388699f },
+    { 8253.75f, 10.268018f, 5.63646314f, 0.0341943248f },
+    { 8254.75f, 10.3612359f, 5.66216845f, 0.0319145216f },
+    { 8255.75f, 10.4497114f, 5.6874599f, 0.0296351472f },
+    { 8256.75f, 10.5323848f, 5.7131151f, 0.0273553207f },
+    { 8257.75f, 10.6107985f, 5.73830313f, 0.0250759887f },
+    { 8258.75f, 10.6826048f, 5.76387124f, 0.0227961874f },
+    { 8259.75f, 10.7512013f, 5.78899025f, 0.0205168585f },
+    { 8260.0f, 10.7658445f, 5.79508005f, 0.0199472233f },
+    { 8260.75f, 10.8116308f, 5.81428627f, 0.0182372681f },
+    { 8261.75f, 10.8711767f, 5.83948912f, 0.0159577573f },
+    { 8262.75f, 10.919081f, 5.86372976f, 0.0136791777f },
+    { 8263.75f, 10.9727214f, 5.8897333f, 0.0113985739f },
+    { 8264.75f, 11.00414f, 5.90836497f, 0.00912562428f },
+    { 8265.75f, 11.0714975f, 5.94033187f, 0.00683716775f },
+    { 8266.75f, 11.080838f, 5.50500766f, 0.00683753943f },
+    { 8267.75f, 11.0901785f, 5.06968345f, 0.00683791111f },
+    { 8268.75f, 11.099519f, 4.63435923f, 0.00683828279f },
+    { 8269.75f, 11.1088595f, 4.19903502f, 0.00683865447f },
+    { 8270.75f, 11.1182001f, 3.76371081f, 0.00683902615f },
+    { 8271.75f, 11.1275406f, 3.32838659f, 0.00683939783f },
+    { 8272.75f, 11.1315968f, 3.29558485f, 0.0091301359f },
+    { 8273.75f, 11.1258376f, 3.28168454f, 0.0113980374f },
+    { 8274.75f, 11.1111375f, 3.25390213f, 0.0136810565f },
+    { 8275.75f, 11.0937665f, 3.23198469f, 0.0159573574f },
+    { 8276.75f, 11.0680671f, 3.20590863f, 0.0182382455f },
+    { 8277.75f, 11.0393304f, 3.18205217f, 0.0205166349f },
+    { 8278.75f, 11.0032074f, 3.15664494f, 0.0227967501f },
+    { 8279.75f, 10.9634085f, 3.13214057f, 0.0250758695f },
+    { 8280.0f, 10.9517742f, 3.12583039f, 0.0256458529f },
+    { 8280.75f, 10.9169298f, 3.10703634f, 0.0273556667f },
+    { 8281.75f, 10.8663175f, 3.08227795f, 0.0296350917f },
+    { 8282.75f, 10.8095534f, 3.05732993f, 0.0319147418f },
+    { 8283.75f, 10.7483316f, 3.032476f, 0.034194308f },
+    { 8300.0f, 9.05785787f, 2.6303586f, 0.0712379341f },
+    { 8320.0f, 5.49341707f, 2.14516321f, 0.116830201f },
+    { 8340.0f, 4.56094012f, 3.19081869f, 0.162422476f },
+    { 8360.0f, 3.62846317f, 4.23647417f, 0.20801475f },
+    { 8380.0f, 7.44374558f, 3.76759053f, 0.253607027f },
+    { 8400.0f, 9.79652591f, 3.28508754f, 0.299199301f },
+    { 8420.0f, 10.3033696f, 2.80136777f, 0.344791573f },
+    { 8440.0f, 8.94077312f, 2.31946746f, 0.390383848f },
+    { 8460.0f, 6.03285022f, 1.84447477f, 0.435976123f },
+    { 8480.0f, 2.17804978f, 1.41711911f, 0.481568392f },
+    { 8500.0f, 1.91386691f, 3.87308948f, 0.527160672f },
+    { 8520.0f, 5.44777594f, 3.45270186f, 0.572752947f },
+    { 8540.0f, 7.84969919f, 2.97293269f, 0.618345221f },
+    { 8560.0f, 8.74838707f, 2.48070874f, 0.663937494f },
+    { 8580.0f, 8.07135017f, 1.97690661f, 0.709529769f },
+    { 8600.0f, 6.03873072f, 1.45068488f, 0.755122044f },
+    { 8620.0f, 3.11970561f, 0.842165822f, 0.800714319f },
+    { 8640.0f, 3.22644322f, 2.12090365f, 0.846306593f },
+    { 8660.0f, 3.33318083f, 3.39964148f, 0.891898867f },
+    { 8680.0f, 5.5376832f, 2.79157596f, 0.937491141f },
+    { 8700.0f, 6.65573015f, 2.22646154f, 0.983083415f },
+    { 8720.0f, 6.58109839f, 1.64840493f, 1.02867569f },
+    { 8740.0f, 5.47091236f, 1.01797332f, 1.07426796f },
+    { 8760.0f, 3.7587475f, 0.240050889f, 1.11986024f },
+    { 8780.0f, 2.41466305f, 5.31085605f, 1.16545253f },
+    { 8800.0f, 2.91106754f, 3.87897068f, 1.21104479f },
+    { 8820.0f, 4.2359903f, 2.9415599f, 1.25663706f },
+    { 8840.0f, 5.16353069f, 2.20416009f, 1.30222933f },
+    { 8860.0f, 5.39899099f, 1.50340137f, 1.34782161f },
+    { 8880.0f, 5.00430359f, 0.770705272f, 1.39341388f },
+    { 8900.0f, 4.25733201f, 6.23168057f, 1.43900616f },
+    { 8920.0f, 3.5951345f, 5.26734622f, 1.48459843f },
+    { 8940.0f, 3.43585701f, 4.19977659f, 1.53019071f },
+    { 8960.0f, 3.78466623f, 3.18306096f, 1.57578298f },
+    { 8980.0f, 4.30648273f, 2.27486097f, 1.62137526f },
+    { 9000.0f, 4.7541749f, 1.43894527f, 1.66696753f },
+    { 9020.0f, 5.02240147f, 0.643091615f, 1.7125598f },
+    { 9040.0f, 5.04017007f, 6.15494049f, 1.75815207f },
+    { 9060.0f, 4.72307184f, 5.39290867f, 1.80374435f },
+    { 9080.0f, 4.01689249f, 4.60419355f, 1.84933661f },
+    { 9100.0f, 3.03614116f, 3.6880375f, 1.8949289f },
+    { 9120.0f, 2.41234759f, 2.43905167f, 1.94052118f },
+    { 9140.0f, 3.13470236f, 1.14400685f, 1.98611346f },
+    { 9160.0f, 4.62738532f, 0.242167574f, 2.03170572f },
+    { 9180.0f, 5.94582747f, 5.82961548f, 2.077298f },
+    { 9200.0f, 6.56778994f, 5.21824796f, 2.12289027f },
+    { 9220.0f, 6.20170991f, 4.64461142f, 2.16848255f },
+    { 9240.0f, 4.76013993f, 4.08100178f, 2.21407482f },
+    { 9260.0f, 2.38147533f, 3.46242364f, 2.2596671f },
+    { 9280.0f, 3.1198673f, 4.67599048f, 2.30525937f },
+    { 9300.0f, 3.85825928f, 5.88955733f, 2.35085165f },
+    { 9320.0f, 6.56301948f, 5.3428553f, 2.39644392f },
+    { 9340.0f, 8.30108115f, 4.83363005f, 2.4420362f },
+    { 9360.0f, 8.66695185f, 4.33914836f, 2.48762847f },
+    { 9380.0f, 7.48899128f, 3.85679545f, 2.53322074f },
+    { 9400.0f, 4.8818891f, 3.3986456f, 2.57881302f },
+    { 9420.0f, 1.28484936f, 3.16079769f, 2.6244053f },
+    { 9440.0f, 2.88001677f, 5.33154022f, 2.66999757f },
+    { 9460.0f, 6.58520238f, 4.92940576f, 2.71558984f },
+    { 9480.0f, 9.2339532f, 4.46377465f, 2.76118211f },
+    { 9500.0f, 10.2479604f, 3.98684792f, 2.80677439f },
+    { 9520.0f, 9.34747618f, 3.50782866f, 2.85236666f },
+    { 9540.0f, 6.61716249f, 3.0346796f, 2.89795894f },
+    { 9560.0f, 2.51615153f, 2.61764092f, 2.9435512f },
+    { 9580.0f, 2.261477f, 5.02421201f, 2.9891435f },
+    { 9600.0f, 6.71253082f, 4.6169275f, 3.03473576f },
+    { 9620.0f, 10.0011535f, 4.13683941f, 3.08032806f },
+    { 9631.875f, 11.1021205f, 3.84566172f, 3.10739833f },
+    { 9632.875f, 11.1610863f, 3.82082629f, 3.10967815f },
+    { 9633.875f, 11.2150294f, 3.79638236f, 3.11195751f },
+    { 9634.875f, 11.2628842f, 3.77146818f, 3.11423738f },
+    { 9635.875f, 11.3061882f, 3.74705953f, 3.11651667f },
+    { 9636.875f, 11.3426336f, 3.72210905f, 3.11879655f },
+    { 9637.875f, 11.3755309f, 3.69771199f, 3.1210758f },
+    { 9638.875f, 11.4000038f, 3.6728766f, 3.12335555f },
+    { 9639.875f, 11.4235118f, 3.64838473f, 3.12563488f },
+    { 9640.0f, 11.4246597f, 3.64625801f, 3.12591876f },
+    { 9640.875f, 11.434767f, 3.62428997f, 3.12791387f },
+    { 9641.875f, 11.4523507f, 3.59911894f, 3.13019404f },
+    { 9642.875f, 11.4461619f, 3.57970075f, 3.1324683f },
+    { 9643.875f, 11.4805131f, 3.54886897f, 3.13475566f },
+    { 9644.875f, 11.4499492f, 3.96237126f, 3.13475521f },
+    { 9645.875f, 11.4193854f, 4.37587354f, 3.13475476f },
+    { 9646.875f, 11.3888216f, 4.78937583f, 3.13475431f },
+    { 9647.875f, 11.3582577f, 5.20287811f, 3.13475386f },
+    { 9648.875f, 11.3276939f, 5.6163804f, 3.13475341f },
+    { 9649.875f, 11.2971301f, 6.02988268f, 3.13475295f },
+    { 9650.875f, 11.2677044f, 6.0619879f, 3.13246285f },
+    { 9651.875f, 11.22144f, 6.07605308f, 3.1301947f },
+    { 9652.875f, 11.1683241f, 6.10381004f, 3.12791161f },
+    { 9653.875f, 11.1107786f, 6.12564646f, 3.12563535f },
+    { 9654.875f, 11.0454312f, 6.15178413f, 3.12335438f },
+    { 9655.875f, 10.9763233f, 6.17559385f, 3.12107606f },
+    { 9656.875f, 10.8999404f, 6.20111307f, 3.11879587f },
+    { 9657.875f, 10.8194264f, 6.2256476f, 3.11651681f },
+    { 9658.875f, 10.7321715f, 6.25092088f, 3.11423696f },
+    { 9659.875f, 10.6405118f, 6.27579037f, 3.11195759f },
+    { 9660.0f, 10.628348f, 6.278851f, 3.11167272f },
+    { 9660.875f, 10.5425326f, 0.017784548f, 3.10967789f },
+    { 9661.875f, 10.4398915f, 0.0428375394f, 3.10739836f },
+    { 9680.0f, 7.70379011f, 0.502867808f, 3.06608044f },
+    { 9700.0f, 3.16875927f, 1.04438986f, 3.02048818f },
+    { 9720.0f, 2.14376711f, 4.52323391f, 2.9748959f },
+    { 9740.0f, 7.15162147f, 5.10046348f, 2.92930363f },
+    { 9760.0f, 10.8815441f, 5.62204961f, 2.88371135f },
+    { 9780.0f, 12.5596462f, 6.14210562f, 2.83811908f },
+    { 9800.0f, 11.8171416f, 0.386431812f, 2.7925268f },
+    { 9820.0f, 8.77391361f, 0.936786132f, 2.74693453f },
+    { 9840.0f, 4.05943514f, 1.59990799f, 2.70134225f },
+    { 9860.0f, 1.98604f, 4.42339603f, 2.65574998f },
+    { 9880.0f, 7.02508236f, 5.36364147f, 2.6101577f },
+    { 9900.0f, 10.8960555f, 5.94695783f, 2.56456543f },
+    { 9920.0f, 12.6326288f, 0.216126367f, 2.51897316f },
+    { 9940.0f, 11.8692888f, 0.770263549f, 2.47338088f },
+    { 9960.0f, 8.76854571f, 1.35409465f, 2.42778861f },
+    { 9980.0f, 4.06583652f, 2.10620518f, 2.38219632f },
+    { 10000.0f, 2.49059057f, 4.67882542f, 2.33660406f },
+    { 10020.0f, 7.37469095f, 5.6889555f, 2.29101179f },
+    { 10040.0f, 11.1848916f, 0.0173617611f, 2.24541951f },
+    { 10060.0f, 12.8495268f, 0.581393375f, 2.19982724f },
+    { 10080.0f, 12.0052101f, 1.13729819f, 2.15423496f },
+    { 10100.0f, 8.8118764f, 1.7078035f, 2.10864269f },
+    { 10120.0f, 3.93460779f, 2.3883551f, 2.06305042f },
+    { 10140.0f, 2.19536389f, 5.31643264f, 2.01745814f },
+    { 10160.0f, 7.45656458f, 6.19286779f, 1.97186586f },
+    { 10180.0f, 11.5501139f, 0.488768516f, 1.92627359f },
+    { 10200.0f, 13.5815439f, 1.03303394f, 1.88068132f },
+    { 10220.0f, 13.1865659f, 1.56414864f, 1.83508904f },
+    { 10240.0f, 10.4678489f, 2.08419634f, 1.78949677f },
+    { 10260.0f, 5.95680961f, 2.57827813f, 1.74390449f },
+    { 10280.0f, 5.48322112f, 1.61286068f, 1.69831222f },
+    { 10300.0f, 5.00963262f, 0.647443241f, 1.65271994f },
+    { 10320.0f, 9.48759246f, 1.12278308f, 1.60712767f },
+    { 10340.0f, 12.2789703f, 1.62361012f, 1.5615354f },
+    { 10360.0f, 12.9844266f, 2.12275104f, 1.51594312f },
+    { 10380.0f, 11.5996537f, 2.60750592f, 1.47035085f },
+    { 10400.0f, 8.50306703f, 3.05185645f, 1.42475857f },
+    { 10420.0f, 4.4507317f, 3.33582255f, 1.37916629f },
+    { 10440.0f, 2.04682719f, 2.41898852f, 1.33357402f },
+    { 10460.0f, 5.15714217f, 2.03523138f, 1.28798176f },
+    { 10480.0f, 8.08538978f, 2.37383114f, 1.24238948f },
+    { 10500.0f, 9.63667699f, 2.79682082f, 1.1967972f },
+    { 10520.0f, 9.65223834f, 3.22459037f, 1.15120493f },
+    { 10540.0f, 8.33293457f, 3.61980918f, 1.10561265f },
+    { 10560.0f, 6.17383469f, 3.92500616f, 1.06002038f },
+    { 10580.0f, 4.01250987f, 3.99257941f, 1.01442808f },
+    { 10600.0f, 3.24853731f, 3.66959086f, 0.968835829f },
+    { 10620.0f, 4.1576003f, 3.51595162f, 0.923243555f },
+    { 10640.0f, 5.17284873f, 3.66794812f, 0.877651281f },
+    { 10660.0f, 5.63894736f, 3.91072993f, 0.832059008f },
+    { 10680.0f, 5.59111153f, 4.14879764f, 0.786466732f },
+    { 10700.0f, 5.30609853f, 4.34998115f, 0.740874458f },
+    { 10720.0f, 5.0229078f, 4.52839566f, 0.695282191f },
+    { 10740.0f, 4.7307849f, 4.72213623f, 0.64968991f },
+    { 10760.0f, 4.21954805f, 4.9412474f, 0.604097638f },
+    { 10780.0f, 3.34339219f, 5.13128874f, 0.558505361f },
+    { 10800.0f, 2.31616717f, 5.10745725f, 0.512913086f },
+    { 10820.0f, 2.1670524f, 4.67879688f, 0.467320819f },
+    { 10840.0f, 3.33374194f, 4.57482705f, 0.421728523f },
+    { 10860.0f, 4.64717123f, 4.84273802f, 0.376136263f },
+    { 10880.0f, 5.42710903f, 5.25078112f, 0.33054398f },
+    { 10900.0f, 5.37774964f, 5.7240421f, 0.284951714f },
+    { 10920.0f, 4.43057647f, 6.24313294f, 0.239359441f },
+    { 10940.0f, 2.72125866f, 0.547209762f, 0.193767156f },
+    { 10960.0f, 2.31019971f, 5.57712437f, 0.148174886f },
+    { 10980.0f, 1.89914076f, 4.32385368f, 0.102582615f },
+    { 11000.0f, 3.84279967f, 5.01076702f, 0.0569903208f },
+    { 11010.0f, 4.58627354f, 5.31393884f, 0.0341942683f },
+    { 11011.0f, 4.64981625f, 5.34409414f, 0.031914406f },
+    { 11012.0f, 4.7112756f, 5.37372134f, 0.0296350924f },
+    { 11013.0f, 4.77053698f, 5.4038929f, 0.0273551233f },
+    { 11014.0f, 4.8277992f, 5.43332899f, 0.0250759492f },
+    { 11015.0f, 4.88257981f, 5.46360083f, 0.0227957953f },
+    { 11016.0f, 4.93575105f, 5.49280425f, 0.0205168325f },
+    { 11017.0f, 4.98578986f, 5.52319067f, 0.0182364856f },
+    { 11018.0f, 5.03528401f, 5.55213998f, 0.0159577706f },
+    { 11019.0f, 5.07993533f, 5.58256078f, 0.0136773069f },
+    { 11020.0f, 5.12740912f, 5.61142436f, 0.0113986545f },
+    { 11021.0f, 5.16463653f, 5.6402038f, 0.00911968487f },
+    { 11022.0f, 5.22284796f, 5.67295459f, 0.00683663071f },
+    { 11023.0f, 5.23866803f, 5.66782574f, 0.00459108351f },
+    { 11024.0f, 7.13118547f, 1.57079617f, 1.60888704e-10f },
+    { 11025.0f, 5.29496494f, 4.71238882f, 1.60888704e-10f },
+};
+
+static const TPqfWidebandPoint PqfWidebandTable5[] = {
+    { 1.0f, 3.39210336f, 0.315454741f, 0.00167018031f },
+    { 2.0f, 3.24513738f, 6.13909956f, 0.00465629634f },
+    { 3.0f, 3.24663001f, 6.21309418f, 0.00683821143f },
+    { 4.0f, 3.23750407f, 6.18231041f, 0.00912949085f },
+    { 5.0f, 3.23298074f, 6.17038071f, 0.0113983304f },
+    { 6.0f, 3.22366372f, 6.14599413f, 0.013680563f },
+    { 7.0f, 3.21522277f, 6.12615684f, 0.0159575938f },
+    { 8.0f, 3.20385904f, 6.10327394f, 0.0182379372f },
+    { 9.0f, 3.19214295f, 6.08175084f, 0.0205167708f },
+    { 10.0f, 3.17824563f, 6.05935901f, 0.0227965538f },
+    { 11.0f, 3.16358859f, 6.03735483f, 0.0250759392f },
+    { 12.0f, 3.1470304f, 6.01517351f, 0.0273555349f },
+    { 13.0f, 3.12946444f, 5.99302123f, 0.0296351383f },
+    { 14.0f, 3.11022073f, 5.97097954f, 0.0319146477f },
+    { 15.0f, 3.08986605f, 5.9488198f, 0.0341943335f },
+    { 20.0f, 2.96729294f, 5.83917072f, 0.0455922631f },
+    { 40.0f, 2.17233814f, 5.42445808f, 0.0911845641f },
+    { 60.0f, 1.03203153f, 5.17390148f, 0.13677682f },
+    { 80.0f, 1.39438996f, 5.95958365f, 0.182369096f },
+    { 100.0f, 1.75674839f, 0.462080505f, 0.227961372f },
+    { 120.0f, 2.74584702f, 0.0976682054f, 0.273553647f },
+    { 140.0f, 3.28458729f, 5.97463684f, 0.319145921f },
+    { 160.0f, 3.27863374f, 5.57802605f, 0.364738194f },
+    { 180.0f, 2.75068703f, 5.22971199f, 0.410330469f },
+    { 200.0f, 1.86617256f, 5.02805067f, 0.455922743f },
+    { 220.0f, 1.12930083f, 5.3426303f, 0.50151499f },
+    { 240.0f, 1.53822027f, 5.91437831f, 0.547107292f },
+    { 260.0f, 2.43860999f, 5.86587834f, 0.592699576f },
+    { 280.0f, 3.11539056f, 5.6293916f, 0.638291841f },
+    { 300.0f, 3.39845401f, 5.37120873f, 0.683884115f },
+    { 320.0f, 3.31553086f, 5.1548772f, 0.729476381f },
+    { 340.0f, 3.03539554f, 5.02412408f, 0.775068667f },
+    { 360.0f, 2.80494872f, 4.99344539f, 0.820660938f },
+    { 380.0f, 2.78419313f, 5.00928401f, 0.86625322f },
+    { 400.0f, 2.90806325f, 5.00159385f, 0.911845487f },
+    { 420.0f, 3.03523039f, 4.97149309f, 0.957437761f },
+    { 440.0f, 3.1649676f, 4.95651039f, 1.00303003f },
+    { 460.0f, 3.44288543f, 4.9553444f, 1.04862231f },
+    { 480.0f, 3.95265756f, 4.91165789f, 1.09421458f },
+    { 500.0f, 4.55223982f, 4.78725938f, 1.13980686f },
+    { 520.0f, 4.97205142f, 4.59690171f, 1.18539913f },
+    { 540.0f, 4.98337414f, 4.37984293f, 1.23099141f },
+    { 560.0f, 4.50508579f, 4.18863303f, 1.27658368f },
+    { 580.0f, 3.70199427f, 4.10903335f, 1.32217595f },
+    { 600.0f, 3.14840742f, 4.25320208f, 1.36776823f },
+    { 620.0f, 3.58638204f, 4.46981752f, 1.41336051f },
+    { 640.0f, 4.74633504f, 4.45692124f, 1.45895278f },
+    { 660.0f, 5.85880561f, 4.2677541f, 1.50454505f },
+    { 680.0f, 6.45857808f, 4.00476737f, 1.55013733f },
+    { 700.0f, 6.3529749f, 3.72623886f, 1.5957296f },
+    { 720.0f, 5.57002147f, 3.47965466f, 1.64132188f },
+    { 740.0f, 4.37413259f, 3.33723416f, 1.68691414f },
+    { 760.0f, 3.3684116f, 3.42067113f, 1.73250642f },
+    { 780.0f, 3.39031425f, 3.67222715f, 1.7780987f },
+    { 800.0f, 4.30579805f, 3.72615022f, 1.82369097f },
+    { 820.0f, 5.26243319f, 3.57565477f, 1.86928324f },
+    { 840.0f, 5.79683634f, 3.33786027f, 1.91487552f },
+    { 860.0f, 5.77686225f, 3.07655265f, 1.9604678f },
+    { 880.0f, 5.25613161f, 2.83025944f, 2.00606007f },
+    { 900.0f, 4.40918944f, 2.63650838f, 2.05165235f },
+    { 920.0f, 3.50400304f, 2.54680822f, 2.09724461f },
+    { 940.0f, 2.8883386f, 2.60787642f, 2.14283688f },
+    { 960.0f, 2.84238785f, 2.74035188f, 2.18842917f },
+    { 980.0f, 3.24706208f, 2.76200978f, 2.23402144f },
+    { 1000.0f, 3.75147167f, 2.63830109f, 2.27961372f },
+    { 1020.0f, 4.10602186f, 2.41850085f, 2.32520599f },
+    { 1040.0f, 4.1758588f, 2.14221677f, 2.37079828f },
+    { 1060.0f, 3.89631559f, 1.83658867f, 2.41639054f },
+    { 1080.0f, 3.26605504f, 1.53146974f, 2.46198281f },
+    { 1100.0f, 2.36716386f, 1.29030593f, 2.50757509f },
+    { 1120.0f, 1.46981921f, 1.32369899f, 2.55316736f },
+    { 1140.0f, 1.38541592f, 1.84373614f, 2.59875963f },
+    { 1160.0f, 2.23815576f, 1.91323131f, 2.64435192f },
+    { 1180.0f, 3.14926339f, 1.61632965f, 2.68994418f },
+    { 1200.0f, 3.75895476f, 1.19998644f, 2.73553646f },
+    { 1220.0f, 3.91395422f, 0.736716462f, 2.78112873f },
+    { 1240.0f, 3.54541676f, 0.256835024f, 2.82672101f },
+    { 1260.0f, 2.65867113f, 6.07199369f, 2.87231328f },
+    { 1280.0f, 1.35116514f, 5.71774783f, 2.91790557f },
+    { 1300.0f, 1.74144133f, 0.208401535f, 2.96349784f },
+    { 1320.0f, 2.13171751f, 0.982240544f, 3.0090901f },
+    { 1340.0f, 3.65062848f, 0.542467087f, 3.05468238f },
+    { 1360.0f, 4.73307721f, 0.0452168339f, 3.10027454f },
+    { 1363.125f, 4.84655488f, 6.24879292f, 3.10739837f },
+    { 1364.125f, 4.87904085f, 6.22337418f, 3.10967787f },
+    { 1365.125f, 4.91010625f, 6.19770939f, 3.1119576f },
+    { 1366.125f, 4.93894405f, 6.17238471f, 3.11423693f },
+    { 1367.125f, 4.96639439f, 6.14650697f, 3.11651685f },
+    { 1368.125f, 4.99151005f, 6.12142329f, 3.11879585f },
+    { 1369.125f, 5.01524233f, 6.09520169f, 3.12107611f },
+    { 1370.125f, 5.03651318f, 6.0707672f, 3.12335437f },
+    { 1371.125f, 5.05638275f, 6.04383485f, 3.12563543f },
+    { 1372.125f, 5.07377288f, 6.02120715f, 3.12791171f },
+    { 1373.125f, 5.08891882f, 5.99262585f, 3.1301948f },
+    { 1374.125f, 5.10289438f, 5.97710348f, 3.13246356f },
+    { 1375.125f, 5.10613432f, 5.94499015f, 3.13475259f },
+    { 1376.125f, 5.11477625f, 5.46685666f, 3.13528029f },
+    { 1377.125f, 5.12341817f, 4.98872317f, 3.135808f },
+    { 1378.125f, 5.1320601f, 4.51058968f, 3.13633571f },
+    { 1379.125f, 5.14070203f, 4.03245619f, 3.13686341f },
+    { 1380.0f, 5.14826372f, 3.61408939f, 3.13732515f },
+    { 1380.125f, 5.14991492f, 3.61685395f, 3.13703968f },
+    { 1381.125f, 5.16312452f, 3.6389705f, 3.13475587f },
+    { 1382.125f, 5.14298341f, 3.66971622f, 3.13247027f },
+    { 1383.125f, 5.14304312f, 3.69215129f, 3.13019401f },
+    { 1384.125f, 5.13283042f, 3.71796402f, 3.12791449f },
+    { 1385.125f, 5.12593538f, 3.74383019f, 3.12563487f },
+    { 1386.125f, 5.11409823f, 3.76931277f, 3.12335582f },
+    { 1387.125f, 5.10217178f, 3.79564787f, 3.1210758f },
+    { 1388.125f, 5.0869626f, 3.82122388f, 3.11879669f },
+    { 1389.125f, 5.07053028f, 3.84758529f, 3.11651669f },
+    { 1390.125f, 5.05144235f, 3.87330379f, 3.11423745f },
+    { 1391.125f, 5.03067325f, 3.89964596f, 3.11195752f },
+    { 1392.125f, 5.00757728f, 3.92546574f, 3.10967819f },
+    { 1393.125f, 4.98253473f, 3.95176f, 3.10739835f },
+    { 1400.0f, 4.75385887f, 4.13137463f, 3.0917261f },
+    { 1420.0f, 3.55450678f, 4.65811818f, 3.04613384f },
+    { 1440.0f, 1.69234822f, 5.20009107f, 3.00054156f },
+    { 1460.0f, 2.25432826f, 4.13005612f, 2.95494928f },
+    { 1480.0f, 2.8163083f, 3.06002117f, 2.909357f },
+    { 1500.0f, 4.69114981f, 3.6008299f, 2.86376473f },
+    { 1520.0f, 5.83296613f, 4.14266331f, 2.81817246f },
+    { 1540.0f, 6.01544366f, 4.69454303f, 2.77258018f },
+    { 1560.0f, 5.18798018f, 5.27020726f, 2.72698791f },
+    { 1580.0f, 3.5063664f, 5.91486262f, 2.68139564f },
+    { 1600.0f, 1.45998898f, 0.670853071f, 2.63580336f },
+    { 1620.0f, 1.80412983f, 2.95952604f, 2.59021109f },
+    { 1640.0f, 3.84652175f, 3.86479218f, 2.54461883f },
+    { 1660.0f, 5.3755443f, 4.52657264f, 2.49902654f },
+    { 1680.0f, 6.02595667f, 5.1608156f, 2.45343426f },
+    { 1700.0f, 5.72789042f, 5.82036217f, 2.40784199f },
+    { 1720.0f, 4.66155679f, 0.278902375f, 2.36224971f },
+    { 1740.0f, 3.3378756f, 1.2314255f, 2.31665744f },
+    { 1760.0f, 2.81027925f, 2.53728965f, 2.27106514f },
+    { 1780.0f, 3.62866346f, 3.74397366f, 2.22547288f },
+    { 1800.0f, 4.73592643f, 4.64992395f, 2.17988062f },
+    { 1820.0f, 5.42567132f, 5.44545991f, 2.13428834f },
+    { 1840.0f, 5.54750831f, 6.23480876f, 2.08869607f },
+    { 1860.0f, 5.25517819f, 0.791100723f, 2.04310379f },
+    { 1880.0f, 4.88699139f, 1.70995189f, 1.99751152f },
+    { 1900.0f, 4.77054192f, 2.68433748f, 1.95191925f },
+    { 1920.0f, 4.95147907f, 3.64388466f, 1.90632697f },
+    { 1940.0f, 5.20030727f, 4.5532034f, 1.8607347f },
+    { 1960.0f, 5.29995296f, 5.43240527f, 1.81514242f },
+    { 1980.0f, 5.20950289f, 0.0339522494f, 1.76955015f },
+    { 2000.0f, 5.04346156f, 0.948240966f, 1.72395787f },
+    { 2020.0f, 4.96075365f, 1.88967076f, 1.67836559f },
+    { 2040.0f, 5.03096915f, 2.83180803f, 1.63277332f },
+    { 2060.0f, 5.19698467f, 3.75095066f, 1.58718106f },
+    { 2080.0f, 5.35986044f, 4.64295893f, 1.54158878f },
+    { 2100.0f, 5.45451566f, 5.51390427f, 1.4959965f },
+    { 2120.0f, 5.44181406f, 0.0853026422f, 1.45040422f },
+    { 2140.0f, 5.26985169f, 0.927124745f, 1.40481196f },
+    { 2160.0f, 4.87227891f, 1.76890077f, 1.35921968f },
+    { 2180.0f, 4.23868195f, 2.64622609f, 1.3136274f },
+    { 2200.0f, 3.54410053f, 3.63013982f, 1.26803513f },
+    { 2220.0f, 3.26747271f, 4.76649537f, 1.22244286f },
+    { 2240.0f, 3.79205004f, 5.87232417f, 1.17685058f },
+    { 2260.0f, 4.73693406f, 0.492138343f, 1.13125832f },
+    { 2280.0f, 5.4856726f, 1.2436194f, 1.08566603f },
+    { 2300.0f, 5.63103328f, 1.91599094f, 1.04007376f },
+    { 2320.0f, 4.98437233f, 2.55565146f, 0.994481478f },
+    { 2340.0f, 3.56555037f, 3.21364403f, 0.94888921f },
+    { 2360.0f, 1.66255274f, 4.10499676f, 0.903296944f },
+    { 2380.0f, 1.36412013f, 0.137386841f, 0.857704661f },
+    { 2400.0f, 3.36023195f, 1.14268171f, 0.812112387f },
+    { 2420.0f, 5.03464702f, 1.7572605f, 0.766520111f },
+    { 2440.0f, 5.90236063f, 2.29939898f, 0.720927832f },
+    { 2460.0f, 5.77117313f, 2.81128389f, 0.675335564f },
+    { 2480.0f, 4.64767483f, 3.30205438f, 0.629743289f },
+    { 2500.0f, 2.72686963f, 3.76192347f, 0.584151015f },
+    { 2520.0f, 2.40187333f, 2.75129868f, 0.53855873f },
+    { 2540.0f, 2.07687703f, 1.7406739f, 0.492966444f },
+    { 2560.0f, 4.07617975f, 2.16285359f, 0.447374189f },
+    { 2580.0f, 5.31833338f, 2.61217123f, 0.401781917f },
+    { 2600.0f, 5.5857587f, 3.06048364f, 0.356189644f },
+    { 2620.0f, 4.84245453f, 3.49719336f, 0.310597371f },
+    { 2640.0f, 3.24088793f, 3.89730393f, 0.265005094f },
+    { 2660.0f, 1.13911277f, 4.04171604f, 0.21941282f },
+    { 2680.0f, 1.43177181f, 2.18671857f, 0.173820562f },
+    { 2700.0f, 3.47569813f, 2.41815602f, 0.128228271f },
+    { 2720.0f, 4.9412159f, 2.82068048f, 0.0826360058f },
+    { 2740.0f, 5.53447108f, 3.2501103f, 0.0370438543f },
+    { 2741.25f, 5.53933676f, 3.27733191f, 0.0341942588f },
+    { 2742.25f, 5.54024472f, 3.29891854f, 0.0319148014f },
+    { 2743.25f, 5.53899337f, 3.32078986f, 0.0296350322f },
+    { 2744.25f, 5.53487497f, 3.34224225f, 0.0273557363f },
+    { 2745.25f, 5.5286885f, 3.36431271f, 0.0250757597f },
+    { 2746.25f, 5.51962402f, 3.3854627f, 0.0227968094f },
+    { 2747.25f, 5.50850419f, 3.40782131f, 0.0205164912f },
+    { 2748.25f, 5.49446207f, 3.4283142f, 0.0182382532f },
+    { 2749.25f, 5.47824449f, 3.45133108f, 0.0159571519f },
+    { 2750.25f, 5.45940071f, 3.47006516f, 0.0136808002f },
+    { 2751.25f, 5.43706826f, 3.49457969f, 0.0113977888f },
+    { 2752.25f, 5.41425772f, 3.50667998f, 0.00912841184f },
+    { 2753.25f, 5.3773103f, 3.53403174f, 0.00684028163f },
+    { 2754.25f, 5.34630917f, 3.97322909f, 0.00639327402f },
+    { 2755.25f, 5.31530803f, 4.41242645f, 0.00594626642f },
+    { 2756.25f, 5.28430689f, 4.8516238f, 0.00549925882f },
+    { 2757.25f, 5.25330576f, 5.29082116f, 0.00505225122f },
+    { 2758.25f, 5.22230462f, 5.73001851f, 0.00460524361f },
+    { 2759.25f, 5.20251277f, 5.75675516f, 0.00683673047f },
+    { 2760.0f, 5.16021813f, 5.74280151f, 0.00854436324f },
+    { 2760.25f, 5.14165732f, 5.73057936f, 0.00912183131f },
+    { 2761.25f, 5.101326f, 5.71190608f, 0.0113986551f },
+    { 2762.25f, 5.05050284f, 5.69052636f, 0.0136780613f },
+    { 2763.25f, 5.00281753f, 5.66891962f, 0.0159577923f },
+    { 2764.25f, 4.95018261f, 5.64789116f, 0.018236809f },
+    { 2765.25f, 4.89719607f, 5.62599008f, 0.0205168617f },
+    { 2766.25f, 4.84101408f, 5.60493767f, 0.0227959713f },
+    { 2767.25f, 4.78339427f, 5.58310537f, 0.0250759893f },
+    { 2768.25f, 4.72321675f, 5.56202648f, 0.0273551973f },
+    { 2769.25f, 4.66131433f, 5.54036608f, 0.0296351283f },
+    { 2770.25f, 4.59715093f, 5.5192468f, 0.0319144766f },
+    { 2771.25f, 4.53105583f, 5.4977565f, 0.0341943058f },
+    { 2780.0f, 3.87144019f, 5.3144545f, 0.0541408511f },
+    { 2800.0f, 1.9312812f, 4.95746103f, 0.0997330923f },
+    { 2820.0f, 2.28937572f, 5.89018229f, 0.145325365f },
+    { 2840.0f, 2.64747024f, 0.539718239f, 0.190917639f },
+    { 2860.0f, 4.42286943f, 0.118657532f, 0.236509921f },
+    { 2880.0f, 5.48115109f, 5.92754673f, 0.282102198f },
+    { 2900.0f, 5.66711535f, 5.4212066f, 0.327694472f },
+    { 2920.0f, 4.99517425f, 4.87325937f, 0.373286762f },
+    { 2940.0f, 3.6552465f, 4.24108029f, 0.41887902f },
+    { 2960.0f, 2.07536574f, 3.33889502f, 0.464471285f },
+    { 2980.0f, 1.56171663f, 1.65513874f, 0.510063611f },
+    { 3000.0f, 2.76817832f, 0.417513529f, 0.555655843f },
+    { 3020.0f, 4.02294367f, 5.90519846f, 0.601248113f },
+    { 3040.0f, 4.86928197f, 5.18365407f, 0.646840393f },
+    { 3060.0f, 5.30393002f, 4.45430952f, 0.692432666f },
+    { 3080.0f, 5.45291402f, 3.69847558f, 0.738024941f },
+    { 3100.0f, 5.41743978f, 2.92263013f, 0.783617215f },
+    { 3120.0f, 5.17128092f, 2.1357241f, 0.82920949f },
+    { 3140.0f, 4.60907313f, 1.3188261f, 0.874801759f },
+    { 3160.0f, 3.77569556f, 0.386833578f, 0.920394028f },
+    { 3180.0f, 3.30211239f, 5.475983f, 0.965986313f },
+    { 3200.0f, 4.24661169f, 4.24897115f, 1.01157859f },
+    { 3220.0f, 6.22082423f, 3.33594904f, 1.05717086f },
+    { 3240.0f, 8.18801596f, 2.61672946f, 1.10276314f },
+    { 3260.0f, 9.42227762f, 1.97983322f, 1.14835542f },
+    { 3280.0f, 9.44386594f, 1.37318112f, 1.19394768f },
+    { 3300.0f, 8.03294685f, 0.757086054f, 1.23953996f },
+    { 3320.0f, 5.33185453f, 0.0440125148f, 1.28513224f },
+    { 3340.0f, 2.55055858f, 4.98903964f, 1.33072449f },
+    { 3360.0f, 4.50734974f, 3.17909359f, 1.37631678f },
+    { 3380.0f, 8.40012729f, 2.38035076f, 1.42190905f },
+    { 3400.0f, 11.5022198f, 1.77744672f, 1.46750133f },
+    { 3420.0f, 12.9713084f, 1.22374472f, 1.5130936f },
+    { 3440.0f, 12.3868634f, 0.683710158f, 1.55868589f },
+    { 3460.0f, 9.72394381f, 0.134278663f, 1.60427815f },
+    { 3480.0f, 5.39199947f, 5.79237267f, 1.64987043f },
+    { 3500.0f, 1.37618505f, 3.8218405f, 1.6954627f },
+    { 3520.0f, 5.85763562f, 2.13191126f, 1.74105499f },
+    { 3540.0f, 10.3542943f, 1.5267688f, 1.78664725f },
+    { 3560.0f, 13.1184162f, 0.994546201f, 1.83223953f },
+    { 3580.0f, 13.565913f, 0.481142149f, 1.8778318f },
+    { 3600.0f, 11.5696493f, 6.2568664f, 1.92342407f },
+    { 3620.0f, 7.47328145f, 5.74608281f, 1.96901636f },
+    { 3640.0f, 2.03914201f, 5.16647818f, 2.01460862f },
+    { 3660.0f, 3.74329987f, 1.70420833f, 2.0602009f },
+    { 3680.0f, 8.71725795f, 1.17441008f, 2.10579318f },
+    { 3700.0f, 11.9487908f, 0.673429763f, 2.15138545f },
+    { 3720.0f, 12.8082229f, 0.179191925f, 2.19697772f },
+    { 3740.0f, 11.1314218f, 5.97385262f, 2.24257f },
+    { 3760.0f, 7.25624927f, 5.49925104f, 2.28816227f },
+    { 3780.0f, 1.97974012f, 5.15446604f, 2.33375454f },
+    { 3800.0f, 3.76073304f, 1.20558151f, 2.37934682f },
+    { 3820.0f, 8.6643139f, 0.772003884f, 2.42493907f },
+    { 3840.0f, 11.8386494f, 0.290729909f, 2.47053137f },
+    { 3860.0f, 12.6484415f, 6.08452905f, 2.51612364f },
+    { 3880.0f, 10.9407664f, 5.59417386f, 2.56171592f },
+    { 3900.0f, 7.06792173f, 5.1112208f, 2.60730819f },
+    { 3920.0f, 1.82470645f, 4.72781771f, 2.65290046f },
+    { 3940.0f, 3.80183596f, 0.853740345f, 2.69849272f },
+    { 3960.0f, 8.61719468f, 0.392320464f, 2.74408501f },
+    { 3980.0f, 11.7261162f, 6.17919591f, 2.78967729f },
+    { 4000.0f, 12.5389916f, 5.6734827f, 2.83526956f },
+    { 4020.0f, 10.9342437f, 5.15961504f, 2.88086184f },
+    { 4040.0f, 7.27202745f, 4.62882713f, 2.92645411f },
+    { 4060.0f, 2.3316404f, 3.98207899f, 2.97204638f },
+    { 4080.0f, 3.0313302f, 0.679347844f, 3.01763866f },
+    { 4100.0f, 7.57128499f, 0.0715677082f, 3.06323091f },
+    { 4119.375f, 10.484604f, 5.83395071f, 3.10739848f },
+    { 4120.0f, 10.5474037f, 5.81733432f, 3.10882325f },
+    { 4120.375f, 10.584045f, 5.80759421f, 3.10967786f },
+    { 4121.375f, 10.678289f, 5.78080279f, 3.11195774f },
+    { 4122.375f, 10.7669665f, 5.75462639f, 3.11423696f },
+    { 4123.375f, 10.8502484f, 5.72767733f, 3.11651704f },
+    { 4124.375f, 10.9281322f, 5.70175085f, 3.11879599f },
+    { 4125.375f, 10.9999171f, 5.67456032f, 3.12107637f },
+    { 4126.375f, 11.0672585f, 5.64903307f, 3.12335489f },
+    { 4127.375f, 11.1264365f, 5.62142175f, 3.12563577f },
+    { 4128.375f, 11.1841076f, 5.59664011f, 3.12791345f },
+    { 4129.375f, 11.2267508f, 5.56837582f, 3.13019515f },
+    { 4130.375f, 11.2784126f, 5.54514842f, 3.13247102f },
+    { 4131.375f, 11.2763199f, 5.51871185f, 3.13475146f },
+    { 4132.375f, 11.3503707f, 5.49586444f, 3.13702573f },
+    { 4133.375f, 11.3710781f, 5.12402719f, 3.13703618f },
+    { 4134.375f, 11.3917854f, 4.75218995f, 3.13704664f },
+    { 4135.375f, 11.4124928f, 4.38035271f, 3.13705709f },
+    { 4136.375f, 11.4332002f, 4.00851547f, 3.13706754f },
+    { 4137.375f, 11.4718878f, 4.06467503f, 3.13475588f },
+    { 4138.375f, 11.4337267f, 4.08911389f, 3.13248009f },
+    { 4139.375f, 11.4329584f, 4.1215066f, 3.1301941f },
+    { 4140.0f, 11.4226286f, 4.13860089f, 3.12876894f },
+    { 4140.375f, 11.4148145f, 4.14586456f, 3.12791719f },
+    { 4141.375f, 11.3984672f, 4.17479011f, 3.12563502f },
+    { 4142.375f, 11.3739047f, 4.20018123f, 3.12335684f },
+    { 4143.375f, 11.3453323f, 4.22797354f, 3.12107596f },
+    { 4144.375f, 11.3108879f, 4.25395464f, 3.11879712f },
+    { 4145.375f, 11.2709597f, 4.28125513f, 3.11651682f },
+    { 4146.375f, 11.2258229f, 4.30756019f, 3.11423765f },
+    { 4147.375f, 11.1749601f, 4.33462537f, 3.11195765f },
+    { 4148.375f, 11.1190633f, 4.36115625f, 3.10967828f },
+    { 4149.375f, 11.0573626f, 4.38812371f, 3.10739845f },
+    { 4160.0f, 10.0844818f, 4.67469251f, 3.08317759f },
+    { 4180.0f, 6.88044588f, 5.23771181f, 3.03758528f },
+    { 4200.0f, 2.5531118f, 5.9801177f, 2.991993f },
+    { 4220.0f, 2.50250976f, 2.65501784f, 2.94640072f },
+    { 4240.0f, 6.56154436f, 3.39946447f, 2.90080845f },
+    { 4260.0f, 9.35681707f, 3.96338645f, 2.85521618f },
+    { 4280.0f, 10.35107f, 4.50064071f, 2.80962391f },
+    { 4300.0f, 9.42992159f, 5.03019132f, 2.76403163f },
+    { 4320.0f, 6.84770658f, 5.55996719f, 2.71843936f },
+    { 4340.0f, 3.15548178f, 6.11178133f, 2.67284708f },
+    { 4360.0f, 3.91057165f, 5.00033239f, 2.62725481f },
+    { 4380.0f, 4.66566152f, 3.88888345f, 2.58166253f },
+    { 4400.0f, 7.39186435f, 4.40917147f, 2.53607026f },
+    { 4420.0f, 8.70902767f, 4.90955558f, 2.49047799f },
+    { 4440.0f, 8.48868117f, 5.39126735f, 2.44488571f },
+    { 4460.0f, 6.89600376f, 5.83972833f, 2.39929344f },
+    { 4480.0f, 4.36386445f, 6.19661873f, 2.35370116f },
+    { 4500.0f, 1.79112978f, 6.04574998f, 2.30810889f },
+    { 4520.0f, 2.49883916f, 4.98863588f, 2.26251661f },
+    { 4540.0f, 4.67306868f, 5.12637295f, 2.21692434f },
+    { 4560.0f, 6.11974743f, 5.47186184f, 2.17133207f },
+    { 4580.0f, 6.58386363f, 5.83501819f, 2.12573979f },
+    { 4600.0f, 6.16196961f, 6.16057742f, 2.08014752f },
+    { 4620.0f, 5.19007814f, 0.114307369f, 2.03455524f },
+    { 4640.0f, 4.2044817f, 0.200158495f, 1.98896297f },
+    { 4660.0f, 3.78369488f, 0.141468681f, 1.94337069f },
+    { 4680.0f, 4.02045538f, 0.104905019f, 1.89777842f },
+    { 4700.0f, 4.46392751f, 0.178319527f, 1.85218615f },
+    { 4720.0f, 4.79167776f, 0.311771607f, 1.80659387f },
+    { 4740.0f, 4.97869825f, 0.456671286f, 1.7610016f },
+    { 4760.0f, 5.11446201f, 0.602224158f, 1.71540932f },
+    { 4780.0f, 5.21768222f, 0.760216681f, 1.66981704f },
+    { 4800.0f, 5.19241235f, 0.934535123f, 1.62422477f },
+    { 4820.0f, 4.94244772f, 1.10361773f, 1.57863249f },
+    { 4840.0f, 4.52434258f, 1.22395247f, 1.53304022f },
+    { 4860.0f, 4.22176044f, 1.26132504f, 1.48744795f },
+    { 4880.0f, 4.3634572f, 1.26783828f, 1.44185568f },
+    { 4900.0f, 4.88281473f, 1.35683914f, 1.3962634f },
+    { 4920.0f, 5.33754556f, 1.55296838f, 1.35067113f },
+    { 4940.0f, 5.32211782f, 1.80722183f, 1.30507885f },
+    { 4960.0f, 4.67441713f, 2.04822223f, 1.25948659f },
+    { 4980.0f, 3.6002754f, 2.15310748f, 1.21389431f },
+    { 5000.0f, 2.98241976f, 1.9387858f, 1.16830203f },
+    { 5020.0f, 3.84095337f, 1.73136716f, 1.12270976f },
+    { 5040.0f, 5.3517736f, 1.87713704f, 1.07711748f },
+    { 5060.0f, 6.45515766f, 2.20355868f, 1.03152521f },
+    { 5080.0f, 6.6144383f, 2.60040735f, 0.985932937f },
+    { 5100.0f, 5.61843406f, 3.01604492f, 0.940340658f },
+    { 5120.0f, 3.54474951f, 3.38307354f, 0.894748394f },
+    { 5140.0f, 1.06171616f, 3.03706214f, 0.849156111f },
+    { 5160.0f, 2.93031876f, 1.8194663f, 0.803563836f },
+    { 5180.0f, 5.8262732f, 2.15467328f, 0.757971561f },
+    { 5200.0f, 7.91367277f, 2.61576787f, 0.712379287f },
+    { 5220.0f, 8.685728f, 3.10977169f, 0.666787012f },
+    { 5240.0f, 7.89876518f, 3.62044113f, 0.62119474f },
+    { 5260.0f, 5.60221671f, 4.14852766f, 0.575602461f },
+    { 5280.0f, 2.14994261f, 4.74974117f, 0.530010188f },
+    { 5300.0f, 1.93322786f, 1.83543941f, 0.484417915f },
+    { 5320.0f, 5.79803415f, 2.45828367f, 0.43882564f },
+    { 5340.0f, 8.77228198f, 2.99795424f, 0.393233366f },
+    { 5360.0f, 10.2386186f, 3.52798794f, 0.347641097f },
+    { 5380.0f, 9.85279793f, 4.05770105f, 0.302048821f },
+    { 5400.0f, 7.61560893f, 4.59496804f, 0.256456543f },
+    { 5420.0f, 3.89512618f, 5.17486265f, 0.21086427f },
+    { 5440.0f, 4.57777701f, 4.01472882f, 0.165271997f },
+    { 5460.0f, 5.26042784f, 2.854595f, 0.119679724f },
+    { 5480.0f, 8.89149056f, 3.40594245f, 0.0740874445f },
+    { 5497.5f, 10.7532469f, 3.86417003f, 0.0341941164f },
+    { 5498.5f, 10.814419f, 3.88983255f, 0.0319147414f },
+    { 5499.5f, 10.8702515f, 3.91594212f, 0.0296348334f },
+    { 5500.0f, 10.896084f, 3.92864725f, 0.0284952659f },
+    { 5500.5f, 10.92116f, 3.94147183f, 0.0273555503f },
+    { 5501.5f, 10.9661494f, 3.96762212f, 0.0250755396f },
+    { 5502.5f, 11.0068652f, 3.99302083f, 0.0227963543f },
+    { 5503.5f, 11.0405881f, 4.01925636f, 0.0205161968f },
+    { 5504.5f, 11.0713728f, 4.04455028f, 0.0182370946f },
+    { 5505.5f, 11.0926438f, 4.07086319f, 0.0159568056f },
+    { 5506.5f, 11.1145792f, 4.09637979f, 0.0136774745f },
+    { 5507.5f, 11.1194582f, 4.12243161f, 0.0113974698f },
+    { 5508.5f, 11.1367637f, 4.15068553f, 0.00911544909f },
+    { 5509.5f, 11.0993537f, 4.17194305f, 0.00684108379f },
+    { 5510.5f, 11.1435193f, 4.24872537f, 0.00451188749f },
+    { 5511.5f, 11.1277742f, 4.41959635f, 0.00497700515f },
+    { 5512.5f, 11.1120291f, 4.59046732f, 0.00544212281f },
+    { 5513.5f, 11.0962841f, 4.7613383f, 0.00590724047f },
+    { 5514.5f, 11.080539f, 4.93220928f, 0.00637235813f },
+    { 5515.5f, 11.0647939f, 5.10308026f, 0.0068374758f },
+    { 5516.5f, 11.0075909f, 5.08347955f, 0.0091082751f },
+    { 5517.5f, 10.9676224f, 5.04822274f, 0.0113983254f },
+    { 5518.5f, 10.9191389f, 5.02559359f, 0.0136745045f },
+    { 5519.5f, 10.8670353f, 4.99714206f, 0.0159574165f },
+    { 5520.0f, 10.8379455f, 4.98525617f, 0.0170962685f },
+    { 5520.5f, 10.8101589f, 4.97302194f, 0.0182355516f },
+    { 5521.5f, 10.7472701f, 4.94641178f, 0.020516541f },
+    { 5522.5f, 10.6801146f, 4.92168823f, 0.0227954645f },
+    { 5523.5f, 10.6067555f, 4.89581168f, 0.0250757139f },
+    { 5524.5f, 10.5291004f, 4.87082779f, 0.027355002f },
+    { 5525.5f, 10.4453933f, 4.84530686f, 0.029634921f },
+    { 5526.5f, 10.3572397f, 4.82021973f, 0.031914391f },
+    { 5527.5f, 10.2633399f, 4.79490919f, 0.034194141f },
+    { 5540.0f, 8.67894257f, 4.4828006f, 0.0626893588f },
+    { 5560.0f, 4.7979419f, 4.00604116f, 0.108281653f },
+    { 5580.0f, 4.91014732f, 5.01344442f, 0.153873927f },
+    { 5600.0f, 5.02235274f, 6.02084769f, 0.199466201f },
+    { 5620.0f, 9.0021567f, 5.55500471f, 0.245058471f },
+    { 5640.0f, 11.2300594f, 5.07672535f, 0.290650749f },
+    { 5660.0f, 11.2241302f, 4.60597871f, 0.336243024f },
+    { 5680.0f, 8.95519796f, 4.16191702f, 0.381835298f },
+    { 5700.0f, 4.91112891f, 3.82797358f, 0.427427572f },
+    { 5720.0f, 1.65509705f, 4.93531365f, 0.473019901f },
+    { 5740.0f, 5.9665625f, 5.42387589f, 0.518612121f },
+    { 5760.0f, 10.0010073f, 5.06239142f, 0.564204395f },
+    { 5780.0f, 12.121846f, 4.63478757f, 0.609796671f },
+    { 5800.0f, 11.7837558f, 4.20570884f, 0.655388944f },
+    { 5820.0f, 9.00340711f, 3.81923229f, 0.700981218f },
+    { 5840.0f, 4.54058383f, 3.66498718f, 0.746573492f },
+    { 5860.0f, 3.35858917f, 4.87827332f, 0.792165758f },
+    { 5880.0f, 8.34640971f, 4.96652897f, 0.837758041f },
+    { 5900.0f, 12.5459957f, 4.61435335f, 0.883350315f },
+    { 5920.0f, 14.379903f, 4.19807921f, 0.928942583f },
+    { 5940.0f, 13.1999211f, 3.77710475f, 0.974534864f },
+    { 5960.0f, 9.03580637f, 3.40737113f, 1.02012714f },
+    { 5980.0f, 3.11679563f, 3.5467116f, 1.06571942f },
+    { 6000.0f, 6.41543501f, 4.96762696f, 1.11131169f },
+    { 6020.0f, 13.8339594f, 4.70468449f, 1.15690396f },
+    { 6040.0f, 19.515876f, 4.28661845f, 1.20249624f },
+    { 6060.0f, 21.9060004f, 3.83772508f, 1.24808851f },
+    { 6080.0f, 20.0999801f, 3.38352226f, 1.29368079f },
+    { 6100.0f, 13.9662915f, 2.94822813f, 1.33927306f },
+    { 6120.0f, 4.37601388f, 2.73717914f, 1.38486533f },
+    { 6140.0f, 8.07409862f, 4.81080614f, 1.4304576f },
+    { 6160.0f, 20.0077363f, 4.45087848f, 1.47604988f },
+    { 6180.0f, 29.7535373f, 3.99514309f, 1.52164216f },
+    { 6200.0f, 35.0740765f, 3.52240598f, 1.56723443f },
+    { 6220.0f, 34.3792351f, 3.04580934f, 1.61282671f },
+    { 6240.0f, 27.0492709f, 2.57469521f, 1.65841898f },
+    { 6260.0f, 13.6884688f, 2.14641812f, 1.70401125f },
+    { 6280.0f, 4.38512228f, 4.29284453f, 1.74960352f },
+    { 6300.0f, 23.1125142f, 4.11460581f, 1.7951958f },
+    { 6320.0f, 39.796055f, 3.65268695f, 1.84078807f },
+    { 6340.0f, 50.4576356f, 3.17078314f, 1.88638035f },
+    { 6360.0f, 51.8679712f, 2.68529929f, 1.93197263f },
+    { 6380.0f, 42.0824537f, 2.20550276f, 1.9775649f },
+    { 6400.0f, 21.1601586f, 1.76961068f, 2.02315717f },
+    { 6420.0f, 8.97289896f, 4.01617404f, 2.06874945f },
+    { 6440.0f, 41.4719442f, 3.73973422f, 2.11434172f },
+    { 6460.0f, 68.7290149f, 3.26711029f, 2.159934f },
+    { 6480.0f, 78.8006782f, 2.77971275f, 2.20552627f },
+    { 6500.0f, 57.1335443f, 2.2988714f, 2.25111855f },
+    { 6520.0f, 13.5346891f, 4.7095444f, 2.29671082f },
+    { 6540.0f, 151.067129f, 4.38152588f, 2.34230309f },
+    { 6560.0f, 375.902418f, 3.89020286f, 2.38789537f },
+    { 6580.0f, 707.745747f, 3.39117067f, 2.43348764f },
+    { 6600.0f, 1165.76702f, 2.88989034f, 2.47907992f },
+    { 6620.0f, 1767.44258f, 2.38765999f, 2.52467219f },
+    { 6640.0f, 2527.53653f, 1.8849738f, 2.57026447f },
+    { 6660.0f, 3457.06876f, 1.38206691f, 2.61585674f },
+    { 6680.0f, 4562.30736f, 0.879062911f, 2.66144901f },
+    { 6700.0f, 5843.84641f, 0.376028382f, 2.70704129f },
+    { 6720.0f, 7295.84988f, 6.1561823f, 2.75263356f },
+    { 6740.0f, 8905.55564f, 5.65316934f, 2.79822584f },
+    { 6760.0f, 10653.1413f, 5.15017721f, 2.84381811f },
+    { 6780.0f, 12512.0281f, 4.64720526f, 2.88941039f },
+    { 6800.0f, 14449.6898f, 4.14424728f, 2.93500266f },
+    { 6820.0f, 16428.9445f, 3.64129912f, 2.98059493f },
+    { 6840.0f, 18409.7421f, 3.13835865f, 3.02618721f },
+    { 6860.0f, 20351.1505f, 2.63541461f, 3.07177948f },
+    { 6875.625f, 21814.6811f, 2.24238213f, 3.10739856f },
+    { 6876.625f, 21906.5856f, 2.21740478f, 3.10967798f },
+    { 6877.625f, 21997.3413f, 2.19203618f, 3.11195784f },
+    { 6878.625f, 22089.0927f, 2.16708701f, 3.11423722f },
+    { 6879.625f, 22178.5959f, 2.14166596f, 3.11651714f },
+    { 6880.0f, 22213.7223f, 2.13254223f, 3.11737164f },
+    { 6880.625f, 22270.5517f, 2.11670006f, 3.11879653f },
+    { 6881.625f, 22358.0409f, 2.09125191f, 3.12107647f },
+    { 6882.625f, 22451.0273f, 2.06609997f, 3.12335603f },
+    { 6883.625f, 22534.5195f, 2.0407553f, 3.12563582f },
+    { 6884.625f, 22630.7891f, 2.01469539f, 3.1279163f },
+    { 6885.625f, 22703.3558f, 1.99011036f, 3.13019511f },
+    { 6886.625f, 22811.1703f, 1.95881791f, 3.13248085f },
+    { 6887.625f, 22829.8171f, 1.94019373f, 3.13475199f },
+    { 6888.625f, 22932.4515f, 1.84140469f, 3.13475241f },
+    { 6889.625f, 23035.086f, 1.74261565f, 3.13475282f },
+    { 6890.625f, 23137.7204f, 1.64382661f, 3.13475324f },
+    { 6891.625f, 23240.3548f, 1.54503757f, 3.13475366f },
+    { 6892.625f, 23342.9892f, 1.44624853f, 3.13475408f },
+    { 6893.625f, 23445.6237f, 1.34745949f, 3.1347545f },
+    { 6894.625f, 23512.4051f, 1.36507752f, 3.1324858f },
+    { 6895.625f, 23593.3271f, 1.40134039f, 3.13019452f },
+    { 6896.625f, 23679.7458f, 1.42373381f, 3.12791835f },
+    { 6897.625f, 23761.3067f, 1.45202112f, 3.1256354f },
+    { 6898.625f, 23848.182f, 1.47608525f, 3.1233571f },
+    { 6899.625f, 23930.1161f, 1.50241491f, 3.12107622f },
+    { 6900.0f, 23963.119f, 1.51116419f, 3.12022214f },
+    { 6900.625f, 24015.8843f, 1.5271161f, 3.11879714f },
+    { 6901.625f, 24097.8452f, 1.55275401f, 3.11651701f },
+    { 6902.625f, 24182.4111f, 1.57773214f, 3.1142376f },
+    { 6903.625f, 24264.1524f, 1.60307694f, 3.11195778f },
+    { 6904.625f, 24347.5942f, 1.62818392f, 3.10967822f },
+    { 6905.625f, 24428.9493f, 1.65339312f, 3.10739855f },
+    { 6920.0f, 25566.7076f, 2.01499559f, 3.074629f },
+    { 6940.0f, 27004.3231f, 2.51792338f, 3.02903673f },
+    { 6960.0f, 28261.0612f, 3.02085557f, 2.98344445f },
+    { 6980.0f, 29331.4387f, 3.52377928f, 2.93785218f },
+    { 7000.0f, 30218.3098f, 4.02670418f, 2.8922599f },
+    { 7020.0f, 30931.8295f, 4.52963122f, 2.84666763f },
+    { 7040.0f, 31488.0135f, 5.03256296f, 2.80107535f },
+    { 7060.0f, 31906.9144f, 5.53550214f, 2.75548308f },
+    { 7080.0f, 32210.7421f, 6.03844953f, 2.70989081f },
+    { 7100.0f, 32422.0474f, 0.258219278f, 2.66429853f },
+    { 7120.0f, 32562.1892f, 0.761179355f, 2.61870626f },
+    { 7140.0f, 32650.1721f, 1.2641403f, 2.57311398f },
+    { 7160.0f, 32701.9293f, 1.76709699f, 2.52752171f },
+    { 7180.0f, 32730.0364f, 2.27004523f, 2.48192943f },
+    { 7200.0f, 32743.8006f, 2.77298202f, 2.43633716f },
+    { 7220.0f, 32749.6336f, 3.27590747f, 2.39074489f },
+    { 7240.0f, 32751.5942f, 3.77882365f, 2.34515261f },
+    { 7260.0f, 32751.9896f, 4.28173584f, 2.29956034f },
+    { 7280.0f, 32751.9476f, 4.78465078f, 2.25396806f },
+    { 7300.0f, 32751.8967f, 5.28757488f, 2.20837579f },
+    { 7320.0f, 32751.9166f, 5.79051274f, 2.16278351f },
+    { 7340.0f, 32751.9645f, 0.0102809586f, 2.11719124f },
+    { 7360.0f, 32751.9933f, 0.513248547f, 2.07159897f },
+    { 7380.0f, 32751.9886f, 1.01622463f, 2.02600669f },
+    { 7400.0f, 32751.9653f, 1.51920234f, 1.98041442f },
+    { 7420.0f, 32751.9465f, 2.02217271f, 1.93482214f },
+    { 7440.0f, 32751.9458f, 2.5251288f, 1.88922987f },
+    { 7460.0f, 32751.9621f, 3.02806652f, 1.84363759f },
+    { 7480.0f, 32751.9832f, 3.53098518f, 1.79804532f },
+    { 7500.0f, 32751.9951f, 4.0338878f, 1.75245304f },
+    { 7520.0f, 32751.9916f, 4.53678134f, 1.70686077f },
+    { 7540.0f, 32751.9762f, 5.03967456f, 1.6612685f },
+    { 7560.0f, 32751.9596f, 5.54257593f, 1.61567622f },
+    { 7580.0f, 32751.9528f, 6.0454927f, 1.57008395f },
+    { 7600.0f, 32751.9601f, 0.265242649f, 1.52449167f },
+    { 7620.0f, 32751.9768f, 0.76819653f, 1.4788994f },
+    { 7640.0f, 32751.9919f, 1.2711656f, 1.43330712f },
+    { 7660.0f, 32751.9949f, 1.77414344f, 1.38771485f },
+    { 7680.0f, 32751.9826f, 2.27712246f, 1.34212258f },
+    { 7700.0f, 32751.9615f, 2.78009642f, 1.2965303f },
+    { 7720.0f, 32751.9454f, 3.2830605f, 1.25093803f },
+    { 7740.0f, 32751.9467f, 3.78601262f, 1.20534575f },
+    { 7760.0f, 32751.9661f, 4.28895291f, 1.15975348f },
+    { 7780.0f, 32751.9893f, 4.79188411f, 1.1141612f },
+    { 7800.0f, 32751.993f, 5.29480973f, 1.06856893f },
+    { 7820.0f, 32751.9631f, 5.79773337f, 1.02297666f },
+    { 7840.0f, 32751.9161f, 0.0174724561f, 0.977384381f },
+    { 7860.0f, 32751.8972f, 0.520399088f, 0.931792107f },
+    { 7880.0f, 32751.9502f, 1.02332796f, 0.886199832f },
+    { 7900.0f, 32751.9875f, 1.52625789f, 0.840607558f },
+    { 7920.0f, 32751.565f, 2.0291886f, 0.795015284f },
+    { 7940.0f, 32749.5259f, 2.5321196f, 0.74942301f },
+    { 7960.0f, 32743.517f, 3.03505211f, 0.703830735f },
+    { 7980.0f, 32729.4157f, 3.53798755f, 0.658238461f },
+    { 8000.0f, 32700.7267f, 4.040928f, 0.612646186f },
+    { 8020.0f, 32648.0452f, 4.54387553f, 0.567053912f },
+    { 8040.0f, 32558.6908f, 5.04683043f, 0.521461638f },
+    { 8060.0f, 32416.6275f, 5.54979145f, 0.475869363f },
+    { 8080.0f, 32202.764f, 6.05275512f, 0.430277089f },
+    { 8100.0f, 31895.6841f, 0.272532003f, 0.384684815f },
+    { 8120.0f, 31472.8225f, 0.775487209f, 0.33909254f },
+    { 8140.0f, 30912.0086f, 1.27843122f, 0.293500266f },
+    { 8160.0f, 30193.2877f, 1.78136035f, 0.247907992f },
+    { 8180.0f, 29300.8034f, 2.28427596f, 0.202315717f },
+    { 8200.0f, 28224.6047f, 2.7871775f, 0.156723445f },
+    { 8220.0f, 26962.0973f, 3.29007746f, 0.111131169f },
+    { 8240.0f, 25518.9635f, 3.79296336f, 0.0655389118f },
+    { 8253.75f, 24428.8356f, 4.13885424f, 0.0341940802f },
+    { 8254.75f, 24347.13f, 4.16386048f, 0.0319146292f },
+    { 8255.75f, 24263.8133f, 4.18919755f, 0.0296348055f },
+    { 8256.75f, 24181.8235f, 4.21420745f, 0.0273553563f },
+    { 8257.75f, 24097.0121f, 4.23956441f, 0.025075515f },
+    { 8258.75f, 24015.1368f, 4.26465096f, 0.0227959934f },
+    { 8259.75f, 23928.1268f, 4.28997414f, 0.020516202f },
+    { 8260.0f, 23909.8902f, 4.29663832f, 0.019945894f },
+    { 8260.75f, 23847.2166f, 4.31537412f, 0.0182363654f },
+    { 8261.75f, 23756.2124f, 4.3404702f, 0.0159568668f },
+    { 8262.75f, 23678.454f, 4.36710042f, 0.0136757761f },
+    { 8263.75f, 23577.4279f, 4.39115985f, 0.0113976067f },
+    { 8264.75f, 23510.5087f, 4.42418463f, 0.00911001774f },
+    { 8265.75f, 23364.221f, 4.44188267f, 0.00684032869f },
+    { 8266.75f, 23287.6714f, 4.50780194f, 0.00684003922f },
+    { 8267.75f, 23211.1219f, 4.57372121f, 0.00683974975f },
+    { 8268.75f, 23134.5723f, 4.63964049f, 0.00683946027f },
+    { 8269.75f, 23058.0228f, 4.70555976f, 0.0068391708f },
+    { 8270.75f, 22981.4732f, 4.77147903f, 0.00683888133f },
+    { 8271.75f, 22904.9237f, 4.8373983f, 0.00683859186f },
+    { 8272.75f, 22814.1768f, 4.82039122f, 0.00910660549f },
+    { 8273.75f, 22717.1717f, 4.78394026f, 0.0113980159f },
+    { 8274.75f, 22632.4609f, 4.76139063f, 0.0136743645f },
+    { 8275.75f, 22538.6481f, 4.73322408f, 0.0159571603f },
+    { 8276.75f, 22452.141f, 4.70900998f, 0.0182356328f },
+    { 8277.75f, 22359.514f, 4.68279718f, 0.0205163694f },
+    { 8278.75f, 22271.3468f, 4.65798748f, 0.0227955696f },
+    { 8279.75f, 22179.1342f, 4.6324364f, 0.0250756041f },
+    { 8280.0f, 22157.8987f, 4.62615826f, 0.0256454965f },
+    { 8280.75f, 22089.6784f, 4.60738308f, 0.0273550967f },
+    { 8281.75f, 21997.5077f, 4.582099f, 0.0296348472f },
+    { 8282.75f, 21907.0225f, 4.55694024f, 0.0319144655f },
+    { 8283.75f, 21814.6941f, 4.53177238f, 0.0341940928f },
+    { 8300.0f, 20291.4679f, 4.12299286f, 0.0712379231f },
+    { 8320.0f, 18348.2212f, 3.61999383f, 0.116830204f },
+    { 8340.0f, 16366.8553f, 3.11697598f, 0.162422479f },
+    { 8360.0f, 14388.3052f, 2.61394343f, 0.208014752f },
+    { 8380.0f, 12452.5636f, 2.11091072f, 0.253607026f },
+    { 8400.0f, 10596.6904f, 1.6079036f, 0.2991993f },
+    { 8420.0f, 8853.04473f, 1.1049513f, 0.344791575f },
+    { 8440.0f, 7248.00304f, 0.602086689f, 0.390383849f },
+    { 8460.0f, 5801.17021f, 0.0993398149f, 0.435976123f },
+    { 8480.0f, 4525.08722f, 5.87991826f, 0.481568398f },
+    { 8500.0f, 3425.38096f, 5.37745398f, 0.527160672f },
+    { 8520.0f, 2501.26719f, 4.87510049f, 0.572752946f },
+    { 8540.0f, 1746.31394f, 4.37276005f, 0.618345221f },
+    { 8560.0f, 1149.36736f, 3.87020265f, 0.663937495f },
+    { 8580.0f, 695.561641f, 3.3668776f, 0.709529769f },
+    { 8600.0f, 367.351876f, 2.86119706f, 0.755122044f },
+    { 8620.0f, 145.536449f, 2.34595751f, 0.800714318f },
+    { 8640.0f, 10.6418008f, 1.55582175f, 0.846306592f },
+    { 8660.0f, 58.5409836f, 4.55915592f, 0.891898866f },
+    { 8680.0f, 78.9622349f, 4.03810346f, 0.937491141f },
+    { 8700.0f, 68.1282521f, 3.53083623f, 0.983083415f },
+    { 8720.0f, 40.4864103f, 3.02481022f, 1.02867569f },
+    { 8740.0f, 7.66330299f, 2.4940218f, 1.07426797f },
+    { 8760.0f, 21.8205031f, 5.18146943f, 1.11986024f },
+    { 8780.0f, 42.5381562f, 4.67374169f, 1.16545251f },
+    { 8800.0f, 52.0207254f, 4.1710013f, 1.21104479f },
+    { 8820.0f, 50.3171389f, 3.67010011f, 1.25663706f },
+    { 8840.0f, 39.4236382f, 3.17243069f, 1.30222934f },
+    { 8860.0f, 22.5901428f, 2.68687114f, 1.34782161f },
+    { 8880.0f, 3.68069577f, 2.40797078f, 1.39341388f },
+    { 8900.0f, 14.078123f, 4.70520564f, 1.43900616f },
+    { 8920.0f, 27.3355627f, 4.23350766f, 1.48459843f },
+    { 8940.0f, 34.4916287f, 3.73609267f, 1.53019071f },
+    { 8960.0f, 34.9925435f, 3.23388618f, 1.57578298f },
+    { 8980.0f, 29.4892658f, 2.73234005f, 1.62137525f },
+    { 9000.0f, 19.590931f, 2.23964324f, 1.66696753f },
+    { 9020.0f, 7.51403906f, 1.8097752f, 1.7125598f },
+    { 9040.0f, 4.64253865f, 4.09129964f, 1.75815208f },
+    { 9060.0f, 14.3364573f, 3.72372211f, 1.80374435f },
+    { 9080.0f, 20.3842601f, 3.23073389f, 1.84933663f },
+    { 9100.0f, 22.036772f, 2.72194819f, 1.8949289f },
+    { 9120.0f, 19.441167f, 2.20727153f, 1.94052118f },
+    { 9140.0f, 13.4966231f, 1.68870542f, 1.98611345f },
+    { 9160.0f, 5.6300654f, 1.1631864f, 2.03170571f },
+    { 9180.0f, 2.50231225f, 3.81920449f, 2.077298f },
+    { 9200.0f, 9.32584056f, 3.27841773f, 2.12289027f },
+    { 9220.0f, 13.6369025f, 2.75077754f, 2.16848255f },
+    { 9240.0f, 14.7931948f, 2.22019972f, 2.21407482f },
+    { 9260.0f, 12.8011794f, 1.6802856f, 2.25966709f },
+    { 9280.0f, 8.28268173f, 1.10936714f, 2.30525937f },
+    { 9300.0f, 2.4379187f, 0.264640172f, 2.35085165f },
+    { 9320.0f, 4.13441306f, 3.58804221f, 2.39644392f },
+    { 9340.0f, 9.16194775f, 2.91922921f, 2.44203619f },
+    { 9360.0f, 12.1671948f, 2.36077328f, 2.48762847f },
+    { 9380.0f, 12.5675514f, 1.81927481f, 2.53322074f },
+    { 9400.0f, 10.3685804f, 1.27487792f, 2.57881302f },
+    { 9420.0f, 6.11426508f, 0.69361328f, 2.62440529f },
+    { 9440.0f, 1.07085828f, 5.65915115f, 2.66999757f },
+    { 9460.0f, 4.8763651f, 3.1203107f, 2.71558984f },
+    { 9480.0f, 9.17423456f, 2.52113084f, 2.76118211f },
+    { 9500.0f, 11.551047f, 1.98604163f, 2.80677439f },
+    { 9520.0f, 11.5465726f, 1.46719132f, 2.85236666f },
+    { 9540.0f, 9.20791684f, 0.955608048f, 2.89795894f },
+    { 9560.0f, 5.05101154f, 0.448023125f, 2.94355121f },
+    { 9580.0f, 5.0674552f, 1.51957083f, 2.98914348f },
+    { 9600.0f, 5.08389886f, 2.59111853f, 3.03473576f },
+    { 9620.0f, 9.03752791f, 2.09407108f, 3.08032804f },
+    { 9631.875f, 10.555375f, 1.80120951f, 3.10739857f },
+    { 9632.875f, 10.6504031f, 1.7766456f, 3.10967817f },
+    { 9633.875f, 10.7393244f, 1.75205971f, 3.11195782f },
+    { 9634.875f, 10.82375f, 1.727418f, 3.11423753f },
+    { 9635.875f, 10.9015169f, 1.7029492f, 3.11651707f },
+    { 9636.875f, 10.9753871f, 1.67808958f, 3.11879705f },
+    { 9637.875f, 11.0417572f, 1.6538867f, 3.12107631f },
+    { 9638.875f, 11.1051452f, 1.62842178f, 3.12335696f },
+    { 9639.875f, 11.1597241f, 1.60479872f, 3.12563555f },
+    { 9640.0f, 11.1657932f, 1.60069936f, 3.12592166f },
+    { 9640.875f, 11.2130141f, 1.57746327f, 3.1279182f },
+    { 9641.875f, 11.2551881f, 1.55550425f, 3.13019471f },
+    { 9642.875f, 11.2998365f, 1.51988342f, 3.13248598f },
+    { 9643.875f, 11.3301289f, 1.5038611f, 3.13475379f },
+    { 9644.875f, 11.3406909f, 1.54954843f, 3.13475359f },
+    { 9645.875f, 11.3512528f, 1.59523577f, 3.13475338f },
+    { 9646.875f, 11.3618147f, 1.6409231f, 3.13475318f },
+    { 9647.875f, 11.3723767f, 1.68661044f, 3.13475297f },
+    { 9648.875f, 11.3829386f, 1.73229777f, 3.13475277f },
+    { 9649.875f, 11.3935006f, 1.7779851f, 3.13475256f },
+    { 9650.875f, 11.4132106f, 1.79431016f, 3.13248363f },
+    { 9651.875f, 11.393509f, 1.82737389f, 3.130195f },
+    { 9652.875f, 11.3837103f, 1.85015019f, 3.12791723f },
+    { 9653.875f, 11.3579757f, 1.87616154f, 3.12563575f },
+    { 9654.875f, 11.3330048f, 1.90008924f, 3.12335645f },
+    { 9655.875f, 11.2979463f, 1.9246189f, 3.12107644f },
+    { 9656.875f, 11.2603895f, 1.94879222f, 3.11879675f },
+    { 9657.875f, 11.2151121f, 1.97288198f, 3.11651713f },
+    { 9658.875f, 11.1659543f, 1.99707897f, 3.11423734f },
+    { 9659.875f, 11.1101502f, 2.02098204f, 3.11195785f },
+    { 9660.0f, 11.102894f, 2.02413902f, 3.11167271f },
+    { 9660.875f, 11.0497872f, 2.04510651f, 3.10967806f },
+    { 9661.875f, 10.98347f, 2.06892904f, 3.10739858f },
+    { 9680.0f, 8.91656426f, 2.49438404f, 3.06608045f },
+    { 9700.0f, 5.10177726f, 2.91470998f, 3.02048817f },
+    { 9720.0f, 4.75109585f, 2.00193065f, 2.9748959f },
+    { 9740.0f, 4.40041445f, 1.08915132f, 2.92930363f },
+    { 9760.0f, 8.09476772f, 1.48752658f, 2.88371135f },
+    { 9780.0f, 10.2270764f, 1.94477433f, 2.83811908f },
+    { 9800.0f, 10.4464852f, 2.41260819f, 2.7925268f },
+    { 9820.0f, 8.79270087f, 2.87749206f, 2.74693453f },
+    { 9840.0f, 5.6589366f, 3.31870804f, 2.70134225f },
+    { 9860.0f, 1.74751723f, 3.54543405f, 2.65574996f },
+    { 9880.0f, 2.53106576f, 1.51026684f, 2.6101577f },
+    { 9900.0f, 5.9250478f, 1.85344614f, 2.56456543f },
+    { 9920.0f, 8.14848992f, 2.31493019f, 2.51897316f },
+    { 9940.0f, 8.86093037f, 2.80243279f, 2.47338088f },
+    { 9960.0f, 8.04151272f, 3.30799226f, 2.42778861f },
+    { 9980.0f, 5.94845997f, 3.84166663f, 2.38219634f },
+    { 10000.0f, 3.06482546f, 4.46885582f, 2.33660406f },
+    { 10020.0f, 3.13722803f, 3.17512048f, 2.29101178f },
+    { 10040.0f, 3.2096306f, 1.88138514f, 2.2454195f },
+    { 10060.0f, 5.3354969f, 2.51709691f, 2.19982723f },
+    { 10080.0f, 6.48488375f, 3.10683856f, 2.15423496f },
+    { 10100.0f, 6.58961699f, 3.71157936f, 2.10864269f },
+    { 10120.0f, 5.81136366f, 4.36601849f, 2.06305041f },
+    { 10140.0f, 4.51456541f, 5.12715224f, 2.01745814f },
+    { 10160.0f, 3.2941812f, 6.10693199f, 1.97186586f },
+    { 10180.0f, 2.94273252f, 1.04655377f, 1.92627359f },
+    { 10200.0f, 3.53252911f, 2.15741634f, 1.88068132f },
+    { 10220.0f, 4.30831947f, 3.05952054f, 1.83508904f },
+    { 10240.0f, 4.86122679f, 3.87187732f, 1.78949677f },
+    { 10260.0f, 5.11818909f, 4.65987167f, 1.74390449f },
+    { 10280.0f, 5.10829687f, 5.448225f, 1.69831222f },
+    { 10300.0f, 4.85958308f, 6.24967182f, 1.65271994f },
+    { 10320.0f, 4.40162146f, 0.802542019f, 1.60712767f },
+    { 10340.0f, 3.85652133f, 1.71620065f, 1.5615354f },
+    { 10360.0f, 3.54195248f, 2.74307732f, 1.51594312f },
+    { 10380.0f, 3.80210214f, 3.79469023f, 1.47035085f },
+    { 10400.0f, 4.50604892f, 4.71854141f, 1.42475857f },
+    { 10420.0f, 5.15826902f, 5.50560913f, 1.37916631f },
+    { 10440.0f, 5.33360995f, 6.21602707f, 1.33357402f },
+    { 10460.0f, 4.80905666f, 0.626533523f, 1.28798174f },
+    { 10480.0f, 3.61549608f, 1.3925807f, 1.24238947f },
+    { 10500.0f, 2.28671127f, 2.50455861f, 1.1967972f },
+    { 10520.0f, 2.56497956f, 4.0710286f, 1.15120494f },
+    { 10540.0f, 4.31033276f, 5.0582696f, 1.10561266f },
+    { 10560.0f, 5.90192173f, 5.73604776f, 1.06002038f },
+    { 10580.0f, 6.67115418f, 0.0341450668f, 1.01442811f },
+    { 10600.0f, 6.31380031f, 0.576318744f, 0.96883583f },
+    { 10620.0f, 4.77319788f, 1.1027648f, 0.923243555f },
+    { 10640.0f, 2.23496671f, 1.64741069f, 0.877651281f },
+    { 10660.0f, 3.18193689f, 0.508621605f, 0.832059007f },
+    { 10680.0f, 4.12890708f, 5.65301782f, 0.786466733f },
+    { 10700.0f, 6.8015817f, 6.15193468f, 0.740874458f },
+    { 10720.0f, 8.40705293f, 0.351242847f, 0.695282187f },
+    { 10740.0f, 8.57739014f, 0.823374609f, 0.649689909f },
+    { 10760.0f, 7.1959181f, 1.28040675f, 0.604097632f },
+    { 10780.0f, 4.44367145f, 1.69184076f, 0.558505361f },
+    { 10800.0f, 3.93382846f, 0.785442432f, 0.512913084f },
+    { 10820.0f, 3.42398547f, 6.16222941f, 0.467320807f },
+    { 10840.0f, 6.94305269f, 0.244326733f, 0.421728543f },
+    { 10860.0f, 9.34216051f, 0.689908823f, 0.376136264f },
+    { 10880.0f, 10.0851706f, 1.1522034f, 0.330543993f },
+    { 10900.0f, 8.95193279f, 1.61742027f, 0.284951715f },
+    { 10920.0f, 6.08200715f, 2.0710735f, 0.23935944f },
+    { 10940.0f, 1.98646671f, 2.39717311f, 0.193767154f },
+    { 10960.0f, 2.73805808f, 0.139451553f, 0.148174874f },
+    { 10980.0f, 6.96630079f, 0.527003371f, 0.102582623f },
+    { 11000.0f, 9.98585678f, 0.999582184f, 0.0569903113f },
+    { 11010.0f, 10.8259225f, 1.24356115f, 0.0341940791f },
+    { 11011.0f, 10.8823156f, 1.26809328f, 0.0319145204f },
+    { 11012.0f, 10.9326768f, 1.29277922f, 0.0296348227f },
+    { 11013.0f, 10.9787029f, 1.31745328f, 0.0273551816f },
+    { 11014.0f, 11.0181818f, 1.34214078f, 0.0250755596f },
+    { 11015.0f, 11.0539183f, 1.3670834f, 0.0227957051f },
+    { 11016.0f, 11.0821565f, 1.39166264f, 0.0205162895f },
+    { 11017.0f, 11.1077784f, 1.41722869f, 0.0182358413f },
+    { 11018.0f, 11.1241937f, 1.44138489f, 0.0159570287f },
+    { 11019.0f, 11.1403331f, 1.46881493f, 0.0136746985f },
+    { 11020.0f, 11.1436202f, 1.49150024f, 0.0113978406f },
+    { 11021.0f, 11.1523665f, 1.52712876f, 0.00910711571f },
+    { 11022.0f, 11.1379342f, 1.54356114f, 0.00683929545f },
+    { 11023.0f, 11.1603471f, 1.67971073f, 0.00444772301f },
+    { 11024.0f, 11.3365376f, 2.17797903f, 0.0019382884f },
+    { 11025.0f, 22.1862632f, 1.57079627f, 5.36295678e-11f },
+};
+
+static const TPqfWidebandPoint PqfWidebandTable6[] = {
+    { 1.0f, 3.39592094f, 3.46689954f, 0.00165582316f },
+    { 2.0f, 3.24494417f, 2.99309888f, 0.00465615984f },
+    { 3.0f, 3.24667862f, 3.06472181f, 0.00683817854f },
+    { 4.0f, 3.2374962f, 3.03166132f, 0.00912942472f },
+    { 5.0f, 3.23318976f, 3.01737802f, 0.0113983382f },
+    { 6.0f, 3.22401027f, 2.99071737f, 0.0136805186f },
+    { 7.0f, 3.21580711f, 2.96852199f, 0.0159575951f },
+    { 8.0f, 3.20461651f, 2.94333066f, 0.0182378972f },
+    { 9.0f, 3.19318206f, 2.91939916f, 0.0205167796f },
+    { 10.0f, 3.17959905f, 2.89466489f, 0.0227965279f },
+    { 11.0f, 3.16522441f, 2.87020259f, 0.0250759637f },
+    { 12.0f, 3.14905418f, 2.84561919f, 0.0273555204f },
+    { 13.0f, 3.13186258f, 2.82097852f, 0.0296351471f },
+    { 14.0f, 3.11308318f, 2.79644547f, 0.0319146466f },
+    { 15.0f, 3.09310337f, 2.7717448f, 0.0341943344f },
+    { 20.0f, 2.97305675f, 2.6486808f, 0.0455922617f },
+    { 40.0f, 2.19069608f, 2.15606806f, 0.0911845489f },
+    { 60.0f, 1.03589847f, 1.66003528f, 0.136776822f },
+    { 80.0f, 1.30403641f, 2.76525005f, 0.182369097f },
+    { 100.0f, 1.57217436f, 3.87046483f, 0.227961372f },
+    { 120.0f, 2.57941532f, 3.40082739f, 0.273553644f },
+    { 140.0f, 3.14673288f, 2.94967029f, 0.319145921f },
+    { 160.0f, 3.18578602f, 2.52532609f, 0.3647382f },
+    { 180.0f, 2.71196047f, 2.15224182f, 0.410330469f },
+    { 200.0f, 1.86707558f, 1.91082876f, 0.455922743f },
+    { 220.0f, 1.07079932f, 2.14555516f, 0.501515048f },
+    { 240.0f, 1.34960536f, 2.81068344f, 0.547107293f },
+    { 260.0f, 2.23104751f, 2.80396873f, 0.592699562f },
+    { 280.0f, 2.93480604f, 2.57679476f, 0.638291841f },
+    { 300.0f, 3.28117359f, 2.32240939f, 0.683884115f },
+    { 320.0f, 3.28849922f, 2.10530547f, 0.729476385f },
+    { 340.0f, 3.10311613f, 1.9627773f, 0.775068659f },
+    { 360.0f, 2.93429656f, 1.90319735f, 0.820660938f },
+    { 380.0f, 2.91780504f, 1.88479295f, 0.86625321f },
+    { 400.0f, 3.01383079f, 1.85503052f, 0.911845487f },
+    { 420.0f, 3.11536638f, 1.81176232f, 0.957437761f },
+    { 440.0f, 3.21856825f, 1.78302304f, 1.00303003f },
+    { 460.0f, 3.44178604f, 1.77023462f, 1.04862231f },
+    { 480.0f, 3.87012221f, 1.72791727f, 1.09421458f },
+    { 500.0f, 4.40618041f, 1.6168561f, 1.13980686f },
+    { 520.0f, 4.82842479f, 1.44275581f, 1.18539913f },
+    { 540.0f, 4.93569399f, 1.23705355f, 1.23099141f },
+    { 560.0f, 4.64115851f, 1.04080171f, 1.27658368f },
+    { 580.0f, 4.03024851f, 0.909249854f, 1.32217595f },
+    { 600.0f, 3.41829069f, 0.913861173f, 1.36776823f },
+    { 620.0f, 3.30041129f, 1.04712786f, 1.4133605f },
+    { 640.0f, 3.83012816f, 1.11516663f, 1.45895277f },
+    { 660.0f, 4.58390391f, 1.02571613f, 1.50454505f },
+    { 680.0f, 5.13749119f, 0.837310744f, 1.55013732f },
+    { 700.0f, 5.28667535f, 0.609924185f, 1.5957296f },
+    { 720.0f, 5.00223315f, 0.383964105f, 1.64132188f },
+    { 740.0f, 4.38275122f, 0.193943672f, 1.68691416f },
+    { 760.0f, 3.61761809f, 0.080299262f, 1.73250643f },
+    { 780.0f, 2.96487829f, 0.087727574f, 1.7780987f },
+    { 800.0f, 2.69300096f, 0.206805067f, 1.82369097f },
+    { 820.0f, 2.87873217f, 0.306190103f, 1.86928326f },
+    { 840.0f, 3.31767938f, 0.282065805f, 1.91487552f },
+    { 860.0f, 3.75807019f, 0.143751579f, 1.96046778f },
+    { 880.0f, 4.01728002f, 6.21019201f, 2.00606008f },
+    { 900.0f, 3.96918583f, 5.94245493f, 2.05165235f },
+    { 920.0f, 3.5423915f, 5.64689289f, 2.09724462f },
+    { 940.0f, 2.74056121f, 5.35731874f, 2.1428369f },
+    { 960.0f, 1.67836494f, 5.17632774f, 2.18842917f },
+    { 980.0f, 1.57342479f, 5.75105299f, 2.23402144f },
+    { 1000.0f, 1.46848464f, 0.0425929364f, 2.27961372f },
+    { 1020.0f, 2.46530119f, 6.12871426f, 2.32520599f },
+    { 1040.0f, 3.16522701f, 5.73575364f, 2.37079826f },
+    { 1060.0f, 3.40575896f, 5.27390059f, 2.41639055f },
+    { 1080.0f, 3.15072847f, 4.77138746f, 2.46198281f },
+    { 1100.0f, 2.45301915f, 4.23226755f, 2.50757509f },
+    { 1120.0f, 1.43391437f, 3.6312523f, 2.55316736f },
+    { 1140.0f, 1.62929287f, 4.20500425f, 2.59875965f },
+    { 1160.0f, 1.82467137f, 4.77875621f, 2.64435193f },
+    { 1180.0f, 2.02004987f, 5.35250816f, 2.68994421f },
+    { 1200.0f, 2.75034806f, 4.74637382f, 2.73553646f },
+    { 1220.0f, 3.07570914f, 4.15647611f, 2.78112874f },
+    { 1240.0f, 2.93192479f, 3.57319374f, 2.826721f },
+    { 1260.0f, 2.31323925f, 2.99166432f, 2.87231328f },
+    { 1280.0f, 1.28568733f, 2.39405709f, 2.91790557f },
+    { 1300.0f, 1.33229153f, 3.48401862f, 2.96349784f },
+    { 1320.0f, 1.37889573f, 4.57398014f, 3.00909011f },
+    { 1340.0f, 2.55518614f, 4.00045304f, 3.05468237f },
+    { 1360.0f, 3.31469809f, 3.45697154f, 3.10027459f },
+    { 1363.125f, 3.38305362f, 3.37343637f, 3.10739833f },
+    { 1364.125f, 3.40161657f, 3.34672397f, 3.10967796f },
+    { 1365.125f, 3.41884466f, 3.32010976f, 3.11195753f },
+    { 1366.125f, 3.43419605f, 3.29357047f, 3.11423704f },
+    { 1367.125f, 3.44830883f, 3.26691736f, 3.11651674f },
+    { 1368.125f, 3.46034185f, 3.24069028f, 3.11879599f },
+    { 1369.125f, 3.47132003f, 3.2138643f, 3.12107595f },
+    { 1370.125f, 3.47998736f, 3.18835401f, 3.1233545f },
+    { 1371.125f, 3.48793956f, 3.16097269f, 3.1256352f },
+    { 1372.125f, 3.49296872f, 3.13746887f, 3.12791171f },
+    { 1373.125f, 3.49790994f, 3.10851718f, 3.13019448f },
+    { 1374.125f, 3.49896841f, 3.09334206f, 3.1324624f },
+    { 1375.125f, 3.50026086f, 3.05869303f, 3.13475374f },
+    { 1376.125f, 3.49648839f, 2.58992376f, 3.13475398f },
+    { 1377.125f, 3.49271592f, 2.12115449f, 3.13475422f },
+    { 1378.125f, 3.48894345f, 1.65238522f, 3.13475445f },
+    { 1379.125f, 3.48517098f, 1.18361595f, 3.13475469f },
+    { 1380.0f, 3.48187007f, 0.773442837f, 3.1347549f },
+    { 1380.125f, 3.48139851f, 0.714846678f, 3.13475493f },
+    { 1381.125f, 3.47762604f, 0.246077407f, 3.13475516f },
+    { 1382.125f, 3.45821915f, 0.279839914f, 3.13246537f },
+    { 1383.125f, 3.4481253f, 0.297759331f, 3.13019414f },
+    { 1384.125f, 3.43149664f, 0.325097446f, 3.12791292f },
+    { 1385.125f, 3.41641238f, 0.349551332f, 3.12563497f },
+    { 1386.125f, 3.39772465f, 0.375754974f, 3.12335514f },
+    { 1387.125f, 3.37872449f, 0.401479091f, 3.12107582f },
+    { 1388.125f, 3.3571479f, 0.427349605f, 3.11879634f },
+    { 1389.125f, 3.33453033f, 0.453347026f, 3.11651666f },
+    { 1390.125f, 3.30983619f, 0.479077112f, 3.11423728f },
+    { 1391.125f, 3.28378276f, 0.505147156f, 3.11195749f },
+    { 1392.125f, 3.25586414f, 0.530825088f, 3.10967809f },
+    { 1393.125f, 3.22643615f, 0.556802607f, 3.10739832f },
+    { 1400.0f, 2.98034086f, 0.733414566f, 3.0917261f },
+    { 1420.0f, 1.87502385f, 1.23072165f, 3.04613379f },
+    { 1440.0f, 1.58747288f, 0.245918311f, 3.00054153f },
+    { 1460.0f, 1.29992191f, 5.54430028f, 2.95494926f },
+    { 1480.0f, 2.73266053f, 6.00747249f, 2.90935701f },
+    { 1500.0f, 3.65055982f, 0.218576431f, 2.86376473f },
+    { 1520.0f, 3.84199164f, 0.717077263f, 2.81817247f },
+    { 1540.0f, 3.2445551f, 1.2144972f, 2.77258018f },
+    { 1560.0f, 1.96438594f, 1.70387084f, 2.72698791f },
+    { 1580.0f, 1.74211691f, 0.671027573f, 2.68139563f },
+    { 1600.0f, 1.51984788f, 5.92136961f, 2.63580336f },
+    { 1620.0f, 2.98274019f, 0.125546489f, 2.59021109f },
+    { 1640.0f, 3.81264333f, 0.633473917f, 2.54461882f },
+    { 1660.0f, 3.82028653f, 1.15798611f, 2.49902654f },
+    { 1680.0f, 2.99816459f, 1.71941956f, 2.45343426f },
+    { 1700.0f, 1.55580643f, 2.44015619f, 2.40784199f },
+    { 1720.0f, 1.95662394f, 1.0348225f, 2.36224971f },
+    { 1740.0f, 2.35744146f, 5.91267412f, 2.31665744f },
+    { 1760.0f, 3.70226473f, 0.260351359f, 2.27106516f },
+    { 1780.0f, 4.32542378f, 0.838397209f, 2.22547288f },
+    { 1800.0f, 4.07588222f, 1.43353678f, 2.17988062f },
+    { 1820.0f, 3.04808921f, 2.12548405f, 2.13428834f },
+    { 1840.0f, 1.79499211f, 3.22034056f, 2.08869605f },
+    { 1860.0f, 2.09792303f, 4.87250256f, 2.0431038f },
+    { 1880.0f, 3.65864576f, 5.82466676f, 1.99751152f },
+    { 1900.0f, 4.94467699f, 0.206929771f, 1.95191924f },
+    { 1920.0f, 5.45142621f, 0.807847689f, 1.90632697f },
+    { 1940.0f, 5.02195161f, 1.41440157f, 1.86073469f },
+    { 1960.0f, 3.77178427f, 2.10525928f, 1.81514242f },
+    { 1980.0f, 2.28466741f, 3.14405203f, 1.76955015f },
+    { 2000.0f, 2.41015118f, 4.7428023f, 1.72395787f },
+    { 2020.0f, 4.12858893f, 5.74054556f, 1.67836562f },
+    { 2040.0f, 5.68484902f, 0.132644061f, 1.63277332f },
+    { 2060.0f, 6.46132336f, 0.725424291f, 1.58718105f },
+    { 2080.0f, 6.24727499f, 1.30410009f, 1.54158879f },
+    { 2100.0f, 5.08472582f, 1.91631618f, 1.4959965f },
+    { 2120.0f, 3.29462929f, 2.67426664f, 1.45040427f },
+    { 2140.0f, 1.93190948f, 4.03042274f, 1.40481194f },
+    { 2160.0f, 2.95891212f, 5.52386604f, 1.35921968f },
+    { 2180.0f, 4.69525042f, 0.0523142893f, 1.31362741f },
+    { 2200.0f, 5.86953263f, 0.684129136f, 1.26803513f },
+    { 2220.0f, 6.15224119f, 1.27681368f, 1.22244285f },
+    { 2240.0f, 5.51709554f, 1.8831199f, 1.17685058f },
+    { 2260.0f, 4.17715887f, 2.56550532f, 1.1312583f },
+    { 2280.0f, 2.66055615f, 3.49514851f, 1.08566603f },
+    { 2300.0f, 2.18244494f, 4.91539603f, 1.04007376f },
+    { 2320.0f, 3.14564823f, 6.06966629f, 0.994481514f },
+    { 2340.0f, 4.13085159f, 0.571375835f, 0.94888921f },
+    { 2360.0f, 4.52756525f, 1.25623175f, 0.903296921f },
+    { 2380.0f, 4.2623344f, 1.94807013f, 0.857704661f },
+    { 2400.0f, 3.54928398f, 2.72683532f, 0.812112387f },
+    { 2420.0f, 2.86184943f, 3.68316237f, 0.766520085f },
+    { 2440.0f, 2.73616334f, 4.76967896f, 0.720927812f },
+    { 2460.0f, 3.07498745f, 5.73530792f, 0.675335565f },
+    { 2480.0f, 3.30813275f, 0.266656471f, 0.629743296f },
+    { 2500.0f, 3.12912814f, 1.04248924f, 0.584151015f },
+    { 2520.0f, 2.61181158f, 1.90843891f, 0.538558741f },
+    { 2540.0f, 2.24136188f, 2.99760834f, 0.492966454f },
+    { 2560.0f, 2.58942237f, 4.12512438f, 0.44737417f },
+    { 2580.0f, 3.33687691f, 4.99290151f, 0.401781915f },
+    { 2600.0f, 3.84686215f, 5.68011359f, 0.356189643f },
+    { 2620.0f, 3.76844829f, 0.00658673452f, 0.31059737f },
+    { 2640.0f, 2.9949711f, 0.602304092f, 0.265005093f },
+    { 2660.0f, 1.63681868f, 1.30975796f, 0.21941282f },
+    { 2680.0f, 1.98695362f, 6.16835629f, 0.173820546f },
+    { 2700.0f, 2.33708855f, 4.74376931f, 0.128228271f },
+    { 2720.0f, 3.95191586f, 5.33369902f, 0.0826360078f },
+    { 2740.0f, 5.01251712f, 5.8339562f, 0.0370438544f },
+    { 2741.25f, 5.05422282f, 5.86387041f, 0.0341943363f },
+    { 2742.25f, 5.08514285f, 5.88778379f, 0.0319146288f },
+    { 2743.25f, 5.1143158f, 5.91141208f, 0.0296351506f },
+    { 2744.25f, 5.14098574f, 5.93513538f, 0.0273554843f },
+    { 2745.25f, 5.16614598f, 5.95865766f, 0.0250759533f },
+    { 2746.25f, 5.18840796f, 5.98204151f, 0.0227964675f },
+    { 2747.25f, 5.20964137f, 6.00552625f, 0.0205168013f },
+    { 2748.25f, 5.22731282f, 6.02830442f, 0.0182377903f },
+    { 2749.25f, 5.24483044f, 6.05202868f, 0.0159576409f },
+    { 2750.25f, 5.25747939f, 6.07306584f, 0.0136802873f },
+    { 2751.25f, 5.27221755f, 6.09803497f, 0.0113983781f },
+    { 2752.25f, 5.27843892f, 6.11136156f, 0.00912879412f },
+    { 2753.25f, 5.29529548f, 6.14262093f, 0.00683791838f },
+    { 2754.25f, 5.29426541f, 5.64211656f, 0.00683801631f },
+    { 2755.25f, 5.29323533f, 5.14161218f, 0.00683811424f },
+    { 2756.25f, 5.29220526f, 4.64110781f, 0.00683821217f },
+    { 2757.25f, 5.29117518f, 4.14060343f, 0.0068383101f },
+    { 2758.25f, 5.29014511f, 3.64009906f, 0.00683840803f },
+    { 2759.25f, 5.28911503f, 3.13959468f, 0.00683850596f },
+    { 2760.0f, 5.27883398f, 3.12317604f, 0.0085495851f },
+    { 2760.25f, 5.27704477f, 3.10859597f, 0.00912996786f },
+    { 2761.25f, 5.26957766f, 3.09705497f, 0.0113982601f },
+    { 2762.25f, 5.25534273f, 3.07236028f, 0.0136807817f },
+    { 2763.25f, 5.24204743f, 3.05279707f, 0.0159575247f },
+    { 2764.25f, 5.22424944f, 3.02982657f, 0.0182380473f },
+    { 2765.25f, 5.20591287f, 3.00856233f, 0.0205167323f },
+    { 2766.25f, 5.18406245f, 2.98625897f, 0.0227966288f },
+    { 2767.25f, 5.16102924f, 2.96456377f, 0.0250759315f },
+    { 2768.25f, 5.13501387f, 2.94262279f, 0.0273555862f },
+    { 2769.25f, 5.10743591f, 2.92086156f, 0.0296351261f },
+    { 2770.25f, 5.07715719f, 2.89918315f, 0.0319146747f },
+    { 2771.25f, 5.04509557f, 2.87749475f, 0.0341943273f },
+    { 2780.0f, 4.67224804f, 2.69231901f, 0.0541408673f },
+    { 2800.0f, 3.2703744f, 2.31798203f, 0.099733099f },
+    { 2820.0f, 1.39899297f, 2.24654097f, 0.145325374f },
+    { 2840.0f, 1.45185184f, 3.69397524f, 0.190917701f },
+    { 2860.0f, 3.50386642f, 3.61736965f, 0.236509929f },
+    { 2880.0f, 5.20722778f, 3.25284084f, 0.282102198f },
+    { 2900.0f, 6.15239883f, 2.83912602f, 0.327694472f },
+    { 2920.0f, 6.14593106f, 2.41151145f, 0.373286756f },
+    { 2940.0f, 5.16360808f, 1.98603941f, 0.41887902f },
+    { 2960.0f, 3.35672809f, 1.59397616f, 0.464471294f },
+    { 2980.0f, 1.10322788f, 1.52208458f, 0.510063595f },
+    { 3000.0f, 1.71291769f, 3.26756055f, 0.555655844f },
+    { 3020.0f, 3.92631242f, 2.99063079f, 0.601248123f },
+    { 3040.0f, 5.54808401f, 2.54658533f, 0.646840397f },
+    { 3060.0f, 6.27149924f, 2.05912849f, 0.692432666f },
+    { 3080.0f, 5.98439336f, 1.53914633f, 0.738024941f },
+    { 3100.0f, 4.76475136f, 0.97124824f, 0.783617215f },
+    { 3120.0f, 2.89424025f, 0.274814648f, 0.829209491f },
+    { 3140.0f, 1.23165034f, 5.1093901f, 0.874801744f },
+    { 3160.0f, 2.37448036f, 3.28659718f, 0.920394026f },
+    { 3180.0f, 4.16462235f, 2.47738801f, 0.965986312f },
+    { 3200.0f, 5.3987268f, 1.80853972f, 1.01157859f },
+    { 3220.0f, 5.87609401f, 1.14725242f, 1.05717086f },
+    { 3240.0f, 5.62970532f, 0.448704888f, 1.10276314f },
+    { 3260.0f, 4.87762578f, 5.95299779f, 1.14835543f },
+    { 3280.0f, 4.01612665f, 5.03548473f, 1.19394769f },
+    { 3300.0f, 3.5693615f, 3.95675935f, 1.23953996f },
+    { 3320.0f, 3.81655377f, 2.8586137f, 1.28513223f },
+    { 3340.0f, 4.45545656f, 1.88195336f, 1.33072451f },
+    { 3360.0f, 5.07533287f, 1.00564034f, 1.37631678f },
+    { 3380.0f, 5.46403662f, 0.17571428f, 1.42190906f },
+    { 3400.0f, 5.55257192f, 5.6392766f, 1.46750133f },
+    { 3420.0f, 5.35843184f, 4.80338066f, 1.5130936f },
+    { 3440.0f, 4.98375542f, 3.92492363f, 1.55868587f },
+    { 3460.0f, 4.63151338f, 2.98367187f, 1.60427815f },
+    { 3480.0f, 4.54241831f, 1.99743843f, 1.64987043f },
+    { 3500.0f, 4.78025854f, 1.03487133f, 1.6954627f },
+    { 3520.0f, 5.11985778f, 0.144987654f, 1.74105498f },
+    { 3540.0f, 5.23827482f, 5.59873386f, 1.78664725f },
+    { 3560.0f, 4.9340264f, 4.78312827f, 1.83223951f },
+    { 3580.0f, 4.24551602f, 3.91057047f, 1.87783179f },
+    { 3600.0f, 3.5651668f, 2.8841164f, 1.92342407f },
+    { 3620.0f, 3.58212694f, 1.72817265f, 1.96901636f },
+    { 3640.0f, 4.38724327f, 0.71018877f, 2.01460862f },
+    { 3660.0f, 5.26931521f, 6.17423323f, 2.0602009f },
+    { 3680.0f, 5.62667544f, 5.46412324f, 2.10579318f },
+    { 3700.0f, 5.17090775f, 4.79474101f, 2.15138545f },
+    { 3720.0f, 3.88860999f, 4.10052694f, 2.19697772f },
+    { 3740.0f, 2.1078973f, 3.17369693f, 2.24257001f },
+    { 3760.0f, 1.60628239f, 1.23786479f, 2.28816227f },
+    { 3780.0f, 3.41073061f, 0.0692591323f, 2.33375454f },
+    { 3800.0f, 5.08373156f, 5.67050178f, 2.37934682f },
+    { 3820.0f, 5.94685211f, 5.0891653f, 2.42493909f },
+    { 3840.0f, 5.77033942f, 4.54419013f, 2.47053137f },
+    { 3860.0f, 4.56300971f, 4.01636852f, 2.51612364f },
+    { 3880.0f, 2.54391815f, 3.49386668f, 2.56171592f },
+    { 3900.0f, 2.43611175f, 4.58154393f, 2.60730819f },
+    { 3920.0f, 2.32830536f, 5.66922117f, 2.65290046f },
+    { 3940.0f, 4.26421005f, 5.16416982f, 2.69849275f },
+    { 3960.0f, 5.36262051f, 4.67048457f, 2.74408501f },
+    { 3980.0f, 5.43723922f, 4.18343783f, 2.78967729f },
+    { 4000.0f, 4.50118587f, 3.70488618f, 2.83526956f },
+    { 4020.0f, 2.76015882f, 3.24877321f, 2.88086184f },
+    { 4040.0f, 2.23111998f, 4.22940334f, 2.92645411f },
+    { 4060.0f, 1.70208115f, 5.21003347f, 2.97204638f },
+    { 4080.0f, 3.55708727f, 4.78940001f, 3.01763866f },
+    { 4100.0f, 4.72005549f, 4.31521336f, 3.06323094f },
+    { 4119.375f, 5.01344663f, 3.84104371f, 3.10739833f },
+    { 4120.0f, 5.00875571f, 3.82552516f, 3.10882311f },
+    { 4120.375f, 5.00538736f, 3.81605363f, 3.10967815f },
+    { 4121.375f, 4.99522203f, 3.79144349f, 3.11195751f },
+    { 4122.375f, 4.98260866f, 3.76635517f, 3.11423738f },
+    { 4123.375f, 4.96819326f, 3.74173643f, 3.11651667f },
+    { 4124.375f, 4.95097633f, 3.71656579f, 3.11879655f },
+    { 4125.375f, 4.93247136f, 3.6919263f, 3.1210758f },
+    { 4126.375f, 4.91049587f, 3.66683948f, 3.12335553f },
+    { 4127.375f, 4.88842032f, 3.64204912f, 3.12563489f },
+    { 4128.375f, 4.86134593f, 3.61767734f, 3.12791383f },
+    { 4129.375f, 4.83714684f, 3.59214069f, 3.13019404f },
+    { 4130.375f, 4.80327749f, 3.57250426f, 3.13246815f },
+    { 4131.375f, 4.78648908f, 3.54118948f, 3.13475564f },
+    { 4132.375f, 4.7440643f, 3.95776886f, 3.1347552f },
+    { 4133.375f, 4.70163951f, 4.37434824f, 3.13475476f },
+    { 4134.375f, 4.65921473f, 4.79092762f, 3.13475432f },
+    { 4135.375f, 4.61678994f, 5.20750699f, 3.13475388f },
+    { 4136.375f, 4.57436515f, 5.62408637f, 3.13475344f },
+    { 4137.375f, 4.53194037f, 6.04066575f, 3.134753f },
+    { 4138.375f, 4.49070413f, 6.07350728f, 3.13246278f },
+    { 4139.375f, 4.44350925f, 6.08819775f, 3.13019468f },
+    { 4140.0f, 4.41346973f, 6.10421468f, 3.12876969f },
+    { 4140.375f, 4.39382947f, 6.11666786f, 3.12791161f },
+    { 4141.375f, 4.34288996f, 6.13928641f, 3.12563534f },
+    { 4142.375f, 4.28914218f, 6.16624847f, 3.12335438f },
+    { 4143.375f, 4.23439775f, 6.19094906f, 3.12107605f },
+    { 4144.375f, 4.17716614f, 6.21740389f, 3.11879587f },
+    { 4145.375f, 4.11880433f, 6.24296815f, 3.1165168f },
+    { 4146.375f, 4.05826125f, 6.26927967f, 3.11423697f },
+    { 4147.375f, 3.99643229f, 0.0121092211f, 3.11195759f },
+    { 4148.375f, 3.93265341f, 0.0384858314f, 3.10967791f },
+    { 4149.375f, 3.86754516f, 0.0648485628f, 3.10739835f },
+    { 4160.0f, 3.08531908f, 0.353721984f, 3.08317751f },
+    { 4180.0f, 1.31229561f, 1.02323617f, 3.03758528f },
+    { 4200.0f, 1.90423942f, 6.02583702f, 2.99199299f },
+    { 4220.0f, 2.49618323f, 4.74525257f, 2.9464007f },
+    { 4240.0f, 3.83153047f, 5.32776974f, 2.90080845f },
+    { 4260.0f, 4.59269729f, 5.89183809f, 2.85521618f },
+    { 4280.0f, 4.73964532f, 0.184852832f, 2.8096239f },
+    { 4300.0f, 4.3384311f, 0.789966623f, 2.76403163f },
+    { 4320.0f, 3.52788238f, 1.44731857f, 2.71843936f },
+    { 4340.0f, 2.49312824f, 2.214653f, 2.67284708f },
+    { 4360.0f, 1.53951553f, 3.29431774f, 2.62725483f },
+    { 4380.0f, 1.48147594f, 4.87832043f, 2.58166253f },
+    { 4400.0f, 2.49079379f, 6.02819782f, 2.53607026f },
+    { 4420.0f, 3.75181398f, 0.533969852f, 2.49047797f },
+    { 4440.0f, 4.9113488f, 1.19733244f, 2.44488571f },
+    { 4460.0f, 5.73728513f, 1.80155579f, 2.39929344f },
+    { 4480.0f, 6.00821762f, 2.37135002f, 2.35370116f },
+    { 4500.0f, 5.53942279f, 2.92162273f, 2.30810889f },
+    { 4520.0f, 4.23409701f, 3.47024653f, 2.26251661f },
+    { 4540.0f, 2.13881897f, 4.0869027f, 2.21692433f },
+    { 4560.0f, 2.927822f, 2.83475829f, 2.17133206f },
+    { 4580.0f, 3.71682503f, 1.58261389f, 2.1257398f },
+    { 4600.0f, 6.57048825f, 2.11844949f, 2.08014752f },
+    { 4620.0f, 8.77171157f, 2.61245023f, 2.03455524f },
+    { 4640.0f, 9.85887952f, 3.09049614f, 1.98896297f },
+    { 4660.0f, 9.50878707f, 3.55715222f, 1.9433707f },
+    { 4680.0f, 7.614965f, 4.00824519f, 1.89777842f },
+    { 4700.0f, 4.34263667f, 4.41124486f, 1.85218615f },
+    { 4720.0f, 4.47914798f, 3.44765091f, 1.80659387f },
+    { 4740.0f, 4.6156593f, 2.48405697f, 1.7610016f },
+    { 4760.0f, 8.77450356f, 2.87890499f, 1.71540932f },
+    { 4780.0f, 11.7820004f, 3.31683498f, 1.66981705f },
+    { 4800.0f, 13.0359709f, 3.76059831f, 1.62422477f },
+    { 4820.0f, 12.2232749f, 4.19733472f, 1.5786325f },
+    { 4840.0f, 9.40044042f, 4.60671063f, 1.53304022f },
+    { 4860.0f, 5.064835f, 4.89604255f, 1.48744795f },
+    { 4880.0f, 1.87930416f, 3.79644127f, 1.44185567f },
+    { 4900.0f, 6.23182234f, 3.313013f, 1.3962634f },
+    { 4920.0f, 10.4782031f, 3.64636753f, 1.35067113f },
+    { 4940.0f, 13.0115799f, 4.05520814f, 1.30507885f },
+    { 4960.0f, 13.3000572f, 4.47473234f, 1.25948658f },
+    { 4980.0f, 11.2854332f, 4.87524296f, 1.2138943f },
+    { 5000.0f, 7.42533791f, 5.19127144f, 1.16830203f },
+    { 5020.0f, 3.19690361f, 4.98869288f, 1.12270976f },
+    { 5040.0f, 4.73570441f, 3.95688362f, 1.07711748f },
+    { 5060.0f, 8.93751038f, 4.10001908f, 1.0315252f },
+    { 5080.0f, 11.7456417f, 4.46283451f, 0.985932934f },
+    { 5100.0f, 12.3482245f, 4.86650283f, 0.940340658f },
+    { 5120.0f, 10.6089538f, 5.26125807f, 0.894748381f },
+    { 5140.0f, 6.9658161f, 5.5719716f, 0.849156108f },
+    { 5160.0f, 2.9737695f, 5.31505228f, 0.803563834f },
+    { 5180.0f, 4.82411842f, 4.32493103f, 0.757971561f },
+    { 5200.0f, 8.96223445f, 4.5026283f, 0.712379286f },
+    { 5220.0f, 11.6652024f, 4.8845656f, 0.666787012f },
+    { 5240.0f, 12.1516757f, 5.3101119f, 0.621194738f },
+    { 5260.0f, 10.2873724f, 5.73762749f, 0.575602466f },
+    { 5280.0f, 6.47096559f, 6.11241102f, 0.530010189f },
+    { 5300.0f, 1.94561053f, 5.89689265f, 0.484417915f },
+    { 5320.0f, 4.46858714f, 4.5267065f, 0.43882564f },
+    { 5340.0f, 8.83541542f, 4.82792081f, 0.393233366f },
+    { 5360.0f, 11.6031923f, 5.26455785f, 0.347641097f },
+    { 5380.0f, 12.1602989f, 5.73084473f, 0.302048816f },
+    { 5400.0f, 10.4118061f, 6.20485874f, 0.256456544f },
+    { 5420.0f, 6.73075599f, 0.384941487f, 0.210864283f },
+    { 5440.0f, 1.90005507f, 0.686793646f, 0.16527201f },
+    { 5460.0f, 3.31480918f, 4.74822815f, 0.119679715f },
+    { 5480.0f, 7.64373541f, 5.16319863f, 0.0740874497f },
+    { 5497.5f, 10.1770849f, 5.5868843f, 0.0341943192f },
+    { 5498.5f, 10.2770423f, 5.61175531f, 0.0319145038f },
+    { 5499.5f, 10.3721933f, 5.63626206f, 0.0296351403f },
+    { 5500.0f, 10.4177837f, 5.6488594f, 0.0284950875f },
+    { 5500.5f, 10.4616203f, 5.66123937f, 0.0273552797f },
+    { 5501.5f, 10.5466425f, 5.68574444f, 0.0250759874f },
+    { 5502.5f, 10.6251509f, 5.7107831f, 0.022796115f },
+    { 5503.5f, 10.7002664f, 5.73531195f, 0.0205168584f },
+    { 5504.5f, 10.7673193f, 5.76025469f, 0.018237127f },
+    { 5505.5f, 10.8333803f, 5.78490046f, 0.015957773f },
+    { 5506.5f, 10.887774f, 5.80909327f, 0.0136788392f },
+    { 5507.5f, 10.9481403f, 5.83447313f, 0.0113986083f },
+    { 5508.5f, 10.9858065f, 5.85388199f, 0.00912453777f },
+    { 5509.5f, 11.0620782f, 5.88500433f, 0.00683700942f },
+    { 5510.5f, 11.0763262f, 5.46826252f, 0.0068374497f },
+    { 5511.5f, 11.0905742f, 5.0515207f, 0.00683788997f },
+    { 5512.5f, 11.1048222f, 4.63477889f, 0.00683833025f },
+    { 5513.5f, 11.1190702f, 4.21803708f, 0.00683877052f },
+    { 5514.5f, 11.1333182f, 3.80129527f, 0.0068392108f },
+    { 5515.5f, 11.1475662f, 3.38455346f, 0.00683965107f },
+    { 5516.5f, 11.1621595f, 3.35213737f, 0.00912986373f },
+    { 5517.5f, 11.1612955f, 3.33791255f, 0.0113979688f },
+    { 5518.5f, 11.1533849f, 3.30993558f, 0.013681052f },
+    { 5519.5f, 11.141479f, 3.28787985f, 0.0159573097f },
+    { 5520.0f, 11.1334983f, 3.2743143f, 0.017098246f },
+    { 5520.5f, 11.1218101f, 3.26152613f, 0.0182382755f },
+    { 5521.5f, 11.0986187f, 3.2374873f, 0.020516599f },
+    { 5522.5f, 11.0681966f, 3.21174803f, 0.0227967809f },
+    { 5523.5f, 11.0339133f, 3.18697767f, 0.0250758483f },
+    { 5524.5f, 10.992952f, 3.16149576f, 0.0273556843f },
+    { 5525.5f, 10.9477551f, 3.13638736f, 0.02963508f },
+    { 5526.5f, 10.896353f, 3.11100142f, 0.0319147626f },
+    { 5527.5f, 10.8403981f, 3.0857277f, 0.0341942996f },
+    { 5540.0f, 9.70982531f, 2.76758821f, 0.062689387f },
+    { 5560.0f, 6.48347476f, 2.25176343f, 0.10828165f },
+    { 5580.0f, 2.12375664f, 1.70125916f, 0.153873925f },
+    { 5600.0f, 2.51856048f, 4.43379571f, 0.199466199f },
+    { 5620.0f, 6.54512377f, 3.88796846f, 0.245058464f },
+    { 5640.0f, 9.23309898f, 3.36430519f, 0.290650749f },
+    { 5660.0f, 10.1303602f, 2.84234149f, 0.33624302f },
+    { 5680.0f, 9.14052488f, 2.3186982f, 0.381835302f },
+    { 5700.0f, 6.52329311f, 1.78901994f, 0.427427572f },
+    { 5720.0f, 2.83089455f, 1.22638753f, 0.473019846f },
+    { 5740.0f, 1.25028464f, 4.09868578f, 0.518612121f },
+    { 5760.0f, 4.89688751f, 3.45207312f, 0.564204395f },
+    { 5780.0f, 7.52261786f, 2.92126872f, 0.609796663f },
+    { 5800.0f, 8.70021301f, 2.40528028f, 0.655388944f },
+    { 5820.0f, 8.3004498f, 1.90042196f, 0.700981218f },
+    { 5840.0f, 6.49023016f, 1.41465765f, 0.746573491f },
+    { 5860.0f, 3.69323332f, 0.989192746f, 0.792165766f },
+    { 5880.0f, 3.26095904f, 1.84388689f, 0.837758041f },
+    { 5900.0f, 2.82868475f, 2.69858104f, 0.883350315f },
+    { 5920.0f, 5.19675551f, 2.32752248f, 0.928942588f },
+    { 5940.0f, 6.53299928f, 1.88847993f, 0.974534864f },
+    { 5960.0f, 6.67773253f, 1.45574336f, 1.02012714f },
+    { 5980.0f, 5.73926134f, 1.06626555f, 1.06571941f },
+    { 6000.0f, 4.09210665f, 0.796991774f, 1.11131169f },
+    { 6020.0f, 2.55751273f, 0.893400509f, 1.15690396f },
+    { 6040.0f, 2.69311435f, 1.36816001f, 1.20249623f },
+    { 6060.0f, 3.9999788f, 1.37554451f, 1.24808851f },
+    { 6080.0f, 5.04161734f, 1.12657616f, 1.29368079f },
+    { 6100.0f, 5.4109256f, 0.822020918f, 1.33927306f },
+    { 6120.0f, 5.11943367f, 0.538494864f, 1.38486533f },
+    { 6140.0f, 4.40876228f, 0.333179047f, 1.43045761f },
+    { 6160.0f, 3.69227501f, 0.263036803f, 1.47604988f },
+    { 6180.0f, 3.42017217f, 0.316018402f, 1.52164216f },
+    { 6200.0f, 3.69558815f, 0.345848887f, 1.56723443f },
+    { 6220.0f, 4.2090099f, 0.266602835f, 1.61282671f },
+    { 6240.0f, 4.68049024f, 0.107038977f, 1.65841898f },
+    { 6260.0f, 4.98631818f, 6.18620176f, 1.70401125f },
+    { 6280.0f, 5.05624638f, 5.95546779f, 1.74960352f },
+    { 6300.0f, 4.80824031f, 5.71183169f, 1.7951958f },
+    { 6320.0f, 4.17527178f, 5.4850549f, 1.84078807f },
+    { 6340.0f, 3.22216355f, 5.35808509f, 1.88638034f },
+    { 6360.0f, 2.44491537f, 5.52924954f, 1.93197262f },
+    { 6380.0f, 2.90361944f, 5.86935059f, 1.97756489f },
+    { 6400.0f, 4.34080761f, 5.82912791f, 2.02315717f },
+    { 6420.0f, 5.74231381f, 5.54457695f, 2.06874945f },
+    { 6440.0f, 6.52469041f, 5.16110478f, 2.11434172f },
+    { 6460.0f, 6.35739894f, 4.73368178f, 2.15993399f },
+    { 6480.0f, 5.11245171f, 4.29087599f, 2.20552627f },
+    { 6500.0f, 2.88323135f, 3.87970256f, 2.25111855f },
+    { 6520.0f, 3.09105033f, 4.81024372f, 2.29671082f },
+    { 6540.0f, 3.29886931f, 5.74078487f, 2.34230309f },
+    { 6560.0f, 6.12847847f, 5.29730462f, 2.38789537f },
+    { 6580.0f, 8.08265774f, 4.80459469f, 2.43348764f },
+    { 6600.0f, 8.71821975f, 4.29527833f, 2.47907992f },
+    { 6620.0f, 7.81361328f, 3.7739218f, 2.52467219f },
+    { 6640.0f, 5.42807452f, 3.23209546f, 2.57026446f },
+    { 6660.0f, 1.93184606f, 2.56577585f, 2.61585674f },
+    { 6680.0f, 2.23703264f, 5.61451696f, 2.66144901f },
+    { 6700.0f, 6.09225264f, 4.96940115f, 2.70704129f },
+    { 6720.0f, 9.02894248f, 4.42501662f, 2.75263356f },
+    { 6740.0f, 10.4169391f, 3.89563832f, 2.79822584f },
+    { 6760.0f, 9.9109633f, 3.37026386f, 2.84381811f },
+    { 6780.0f, 7.52054128f, 2.84307803f, 2.88941039f },
+    { 6800.0f, 3.62895432f, 2.29356716f, 2.93500266f },
+    { 6820.0f, 1.10535336f, 5.19083319f, 2.98059492f },
+    { 6840.0f, 5.71103526f, 4.51042551f, 3.02618721f },
+    { 6860.0f, 9.3476751f, 3.98413089f, 3.07177948f },
+    { 6875.625f, 11.0122463f, 3.58296768f, 3.10739832f },
+    { 6876.625f, 11.0761884f, 3.55735596f, 3.10967804f },
+    { 6877.625f, 11.1355409f, 3.53199662f, 3.1119575f },
+    { 6878.625f, 11.1884484f, 3.50645817f, 3.11423718f },
+    { 6879.625f, 11.2372354f, 3.48110612f, 3.11651668f },
+    { 6880.0f, 11.2530246f, 3.47146549f, 3.11737165f },
+    { 6880.625f, 11.2789145f, 3.45575504f, 3.11879621f },
+    { 6881.625f, 11.3173202f, 3.43031395f, 3.12107585f },
+    { 6882.625f, 11.347158f, 3.4054711f, 3.12335489f },
+    { 6883.625f, 11.3758401f, 3.37967717f, 3.12563501f },
+    { 6884.625f, 11.3929343f, 3.35646773f, 3.12791239f },
+    { 6885.625f, 11.4138215f, 3.32934986f, 3.13019425f },
+    { 6886.625f, 11.4152217f, 3.31371344f, 3.13246387f },
+    { 6887.625f, 11.4387465f, 3.28015599f, 3.13475474f },
+    { 6888.625f, 11.4209487f, 3.78381008f, 3.13475465f },
+    { 6889.625f, 11.4031508f, 4.28746417f, 3.13475457f },
+    { 6890.625f, 11.3853529f, 4.79111825f, 3.13475448f },
+    { 6891.625f, 11.367555f, 5.29477234f, 3.13475439f },
+    { 6892.625f, 11.3497571f, 5.79842643f, 3.1347543f },
+    { 6893.625f, 11.3319592f, 0.0188952128f, 3.13475421f },
+    { 6894.625f, 11.2858362f, 0.0525576174f, 3.1324628f },
+    { 6895.625f, 11.2504777f, 0.066958676f, 3.13019438f },
+    { 6896.625f, 11.1991125f, 0.0943606302f, 3.12791195f },
+    { 6897.625f, 11.1493132f, 0.11686799f, 3.1256351f },
+    { 6898.625f, 11.0888834f, 0.14268031f, 3.12335465f },
+    { 6899.625f, 11.0266766f, 0.166975852f, 3.1210759f },
+    { 6900.0f, 11.0001507f, 0.176819593f, 3.12022055f },
+    { 6900.625f, 10.9561308f, 0.192232043f, 3.11879608f },
+    { 6901.625f, 10.8822618f, 0.217073432f, 3.11651671f },
+    { 6902.625f, 10.8013209f, 0.242126284f, 3.11423709f },
+    { 6903.625f, 10.7161808f, 0.267127432f, 3.11195751f },
+    { 6904.625f, 10.6247228f, 0.292054646f, 3.10967799f },
+    { 6905.625f, 10.5286731f, 0.317088741f, 3.10739832f },
+    { 6920.0f, 8.58215493f, 0.672781939f, 3.07462902f },
+    { 6940.0f, 4.43034354f, 1.14030307f, 3.02903673f },
+    { 6960.0f, 5.08342779f, 0.135079301f, 2.98344446f },
+    { 6980.0f, 5.73651203f, 5.41304084f, 2.93785218f },
+    { 7000.0f, 9.6914443f, 5.88459459f, 2.8922599f },
+    { 7020.0f, 11.7377454f, 0.0849455194f, 2.84666763f },
+    { 7040.0f, 11.4156283f, 0.565193021f, 2.80107535f },
+    { 7060.0f, 8.7440469f, 1.02895605f, 2.75548308f },
+    { 7080.0f, 4.25054922f, 1.41113375f, 2.7098908f },
+    { 7100.0f, 1.59576296f, 5.81946658f, 2.66429853f },
+    { 7120.0f, 6.73919994f, 5.8598187f, 2.61870625f },
+    { 7140.0f, 10.783038f, 0.00957164637f, 2.57311398f },
+    { 7160.0f, 12.6741094f, 0.471737038f, 2.52752171f },
+    { 7180.0f, 11.9335349f, 0.934782261f, 2.48192944f },
+    { 7200.0f, 8.62778407f, 1.37709053f, 2.43633716f },
+    { 7220.0f, 3.42493633f, 1.66682198f, 2.39074488f },
+    { 7240.0f, 3.16678693f, 5.94072255f, 2.34515259f },
+    { 7260.0f, 8.95140369f, 6.20089444f, 2.29956034f },
+    { 7280.0f, 13.2067222f, 0.359474678f, 2.25396806f },
+    { 7300.0f, 14.8274185f, 0.827166137f, 2.20837579f },
+    { 7320.0f, 13.2634918f, 1.30307488f, 2.16278351f },
+    { 7340.0f, 8.59034989f, 1.78129141f, 2.11719124f },
+    { 7360.0f, 1.52824929f, 2.23198176f, 2.07159893f },
+    { 7380.0f, 6.66214463f, 5.90747072f, 2.02600669f },
+    { 7400.0f, 14.3773017f, 0.106330982f, 1.98041442f },
+    { 7420.0f, 19.9731535f, 0.594160448f, 1.93482214f },
+    { 7440.0f, 22.0732556f, 1.08593419f, 1.88922987f },
+    { 7460.0f, 19.8623076f, 1.58416924f, 1.84363759f },
+    { 7480.0f, 13.2975533f, 2.1011629f, 1.79804532f },
+    { 7500.0f, 3.27398785f, 2.82634779f, 1.75245304f },
+    { 7520.0f, 9.05727493f, 6.04442127f, 1.70686076f },
+    { 7540.0f, 20.996693f, 0.318147129f, 1.66126849f },
+    { 7560.0f, 30.4577776f, 0.82929377f, 1.61567622f },
+    { 7580.0f, 35.2821542f, 1.33325821f, 1.57008395f },
+    { 7600.0f, 33.9619992f, 1.8371793f, 1.52449167f },
+    { 7620.0f, 25.9866271f, 2.34692612f, 1.4788994f },
+    { 7640.0f, 12.0711257f, 2.8908459f, 1.43330712f },
+    { 7660.0f, 5.99712435f, 0.00434395916f, 1.38771485f },
+    { 7680.0f, 24.8910233f, 0.630202766f, 1.34212258f },
+    { 7700.0f, 41.185036f, 1.1476823f, 1.2965303f },
+    { 7720.0f, 51.0889277f, 1.65528129f, 1.25093803f },
+    { 7740.0f, 51.4696765f, 2.16000774f, 1.20534575f },
+    { 7760.0f, 40.5384936f, 2.66285904f, 1.15975348f },
+    { 7780.0f, 18.5337073f, 3.15909288f, 1.1141612f },
+    { 7800.0f, 11.7265716f, 0.559291155f, 1.06856893f },
+    { 7820.0f, 44.4344461f, 1.04588559f, 1.02297666f },
+    { 7840.0f, 70.6724566f, 1.54594637f, 0.977384381f },
+    { 7860.0f, 78.4429859f, 2.04391183f, 0.931792107f },
+    { 7880.0f, 52.9777869f, 2.52369537f, 0.886199831f },
+    { 7900.0f, 23.2340127f, 0.0859127483f, 0.840607558f },
+    { 7920.0f, 168.122601f, 0.468637063f, 0.795015284f },
+    { 7940.0f, 402.155547f, 0.961565143f, 0.74942301f },
+    { 7960.0f, 745.038897f, 1.46223573f, 0.703830735f },
+    { 7980.0f, 1215.82278f, 1.96493841f, 0.658238461f },
+    { 8000.0f, 1831.77339f, 2.46830598f, 0.612646186f },
+    { 8020.0f, 2607.34911f, 2.97184826f, 0.567053912f },
+    { 8040.0f, 3553.1676f, 3.47535805f, 0.521461638f },
+    { 8060.0f, 4675.00314f, 3.9787498f, 0.475869364f },
+    { 8080.0f, 5972.87562f, 4.48199756f, 0.430277089f },
+    { 8100.0f, 7440.31588f, 4.9851077f, 0.384684815f },
+    { 8120.0f, 9063.89867f, 5.48810454f, 0.33909254f },
+    { 8140.0f, 10823.1477f, 5.99101932f, 0.293500266f },
+    { 8160.0f, 12690.8838f, 0.210699777f, 0.247907992f },
+    { 8180.0f, 14634.0809f, 0.713545227f, 0.202315718f },
+    { 8200.0f, 16615.211f, 1.21639681f, 0.156723441f },
+    { 8220.0f, 18594.0472f, 1.71926471f, 0.111131169f },
+    { 8240.0f, 20529.8349f, 2.22217799f, 0.0655388769f },
+    { 8253.75f, 21815.5833f, 2.56779831f, 0.0341943313f },
+    { 8254.75f, 21906.8323f, 2.59308477f, 0.0319145548f },
+    { 8255.75f, 21998.9217f, 2.61804048f, 0.0296351509f },
+    { 8256.75f, 22089.1916f, 2.6433233f, 0.0273553728f },
+    { 8257.75f, 22181.4238f, 2.66825936f, 0.0250759866f },
+    { 8258.75f, 22270.3283f, 2.69346589f, 0.0227962808f },
+    { 8259.75f, 22363.3769f, 2.71843637f, 0.0205168443f },
+    { 8260.0f, 22383.2567f, 2.72434528f, 0.0199473457f },
+    { 8260.75f, 22450.0924f, 2.74332907f, 0.0182374542f },
+    { 8261.75f, 22545.6966f, 2.76852823f, 0.0159577235f },
+    { 8262.75f, 22628.1015f, 2.79219136f, 0.0136795882f },
+    { 8263.75f, 22732.1487f, 2.81842838f, 0.0113985267f },
+    { 8264.75f, 22802.9047f, 2.83573695f, 0.00912686761f },
+    { 8265.75f, 22950.0917f, 2.86825866f, 0.0068373958f },
+    { 8266.75f, 23026.8336f, 2.40972359f, 0.00683767562f },
+    { 8267.75f, 23103.5754f, 1.95118852f, 0.00683795544f },
+    { 8268.75f, 23180.3172f, 1.49265345f, 0.00683823526f },
+    { 8269.75f, 23257.0591f, 1.03411838f, 0.00683851508f },
+    { 8270.75f, 23333.8009f, 0.575583306f, 0.00683879489f },
+    { 8271.75f, 23410.5428f, 0.117048234f, 0.00683907471f },
+    { 8272.75f, 23499.1125f, 0.0837889432f, 0.00913026319f },
+    { 8273.75f, 23592.9878f, 0.0699025114f, 0.0113981221f },
+    { 8274.75f, 23673.9165f, 0.0421570574f, 0.0136810015f },
+    { 8275.75f, 23763.6435f, 0.0200293502f, 0.0159574318f },
+    { 8276.75f, 23845.0448f, 6.27713286f, 0.0182381875f },
+    { 8277.75f, 23932.2609f, 6.2530511f, 0.0205166774f },
+    { 8278.75f, 24014.0397f, 6.22756501f, 0.022796705f },
+    { 8279.75f, 24099.4997f, 6.20282076f, 0.0250758977f },
+    { 8280.0f, 24118.7845f, 6.19652506f, 0.025645812f },
+    { 8280.75f, 24181.2906f, 6.17757824f, 0.0273556327f },
+    { 8281.75f, 24265.3728f, 6.15256671f, 0.0296351093f },
+    { 8282.75f, 24346.9186f, 6.12742925f, 0.0319147187f },
+    { 8283.75f, 24429.8311f, 6.10230117f, 0.0341943187f },
+    { 8300.0f, 25708.9655f, 5.69375396f, 0.0712379342f },
+    { 8320.0f, 27129.9844f, 5.19077727f, 0.116830202f },
+    { 8340.0f, 28369.3428f, 4.68779282f, 0.162422476f },
+    { 8360.0f, 29422.2683f, 4.18481473f, 0.208014752f },
+    { 8380.0f, 30292.3539f, 3.6818519f, 0.253607026f },
+    { 8400.0f, 30990.3696f, 3.17890556f, 0.2991993f },
+    { 8420.0f, 31532.7836f, 2.67597549f, 0.344791575f },
+    { 8440.0f, 31939.9356f, 2.1730578f, 0.390383849f },
+    { 8460.0f, 32234.1384f, 1.67014746f, 0.435976123f },
+    { 8480.0f, 32437.8942f, 1.16723846f, 0.481568398f },
+    { 8500.0f, 32572.3821f, 0.664325854f, 0.527160672f },
+    { 8520.0f, 32656.3436f, 0.161406084f, 0.572752946f },
+    { 8540.0f, 32705.4016f, 5.94166228f, 0.618345221f },
+    { 8560.0f, 32731.817f, 5.43872472f, 0.663937495f },
+    { 8580.0f, 32744.6058f, 4.93578016f, 0.709529769f },
+    { 8600.0f, 32749.9352f, 4.4328305f, 0.755122044f },
+    { 8620.0f, 32751.6733f, 3.92987799f, 0.800714318f },
+    { 8640.0f, 32751.9936f, 3.42692364f, 0.846306592f },
+    { 8660.0f, 32751.9407f, 2.9239676f, 0.891898867f },
+    { 8680.0f, 32751.896f, 2.42100982f, 0.937491141f },
+    { 8700.0f, 32751.9208f, 1.91805011f, 0.983083415f },
+    { 8720.0f, 32751.9687f, 1.41508987f, 1.02867569f },
+    { 8740.0f, 32751.9943f, 0.912130879f, 1.07426796f },
+    { 8760.0f, 32751.987f, 0.409176502f, 1.11986024f },
+    { 8780.0f, 32751.9632f, 6.18941537f, 1.16545251f },
+    { 8800.0f, 32751.9456f, 5.68648084f, 1.21104479f },
+    { 8820.0f, 32751.9467f, 5.18355947f, 1.25663706f },
+    { 8840.0f, 32751.9641f, 4.68065089f, 1.30222934f },
+    { 8860.0f, 32751.9848f, 4.17775163f, 1.34782161f },
+    { 8880.0f, 32751.9954f, 3.67485588f, 1.39341388f },
+    { 8900.0f, 32751.9904f, 3.17195628f, 1.43900616f },
+    { 8920.0f, 32751.9747f, 2.66904501f, 1.48459843f },
+    { 8940.0f, 32751.9585f, 2.16611672f, 1.53019071f },
+    { 8960.0f, 32751.953f, 1.6631685f, 1.57578298f },
+    { 8980.0f, 32751.9615f, 1.16020137f, 1.62137526f },
+    { 9000.0f, 32751.9784f, 0.657220264f, 1.66696753f },
+    { 9020.0f, 32751.9928f, 0.154232521f, 1.7125598f },
+    { 9040.0f, 32751.9944f, 5.934433f, 1.75815208f },
+    { 9060.0f, 32751.9808f, 5.43145925f, 1.80374435f },
+    { 9080.0f, 32751.9596f, 4.92850221f, 1.84933663f },
+    { 9100.0f, 32751.9445f, 4.42556474f, 1.8949289f },
+    { 9120.0f, 32751.9479f, 3.92264421f, 1.94052118f },
+    { 9140.0f, 32751.9686f, 3.41973524f, 1.98611345f },
+    { 9160.0f, 32751.9908f, 2.91683059f, 2.03170573f },
+    { 9180.0f, 32751.9916f, 2.41392186f, 2.077298f },
+    { 9200.0f, 32751.9591f, 1.91100252f, 2.12289027f },
+    { 9220.0f, 32751.9113f, 1.40806894f, 2.16848255f },
+    { 9240.0f, 32751.8991f, 0.905121249f, 2.21407482f },
+    { 9260.0f, 32751.9579f, 0.402162621f, 2.2596671f },
+    { 9280.0f, 32751.9787f, 6.18238407f, 2.30525937f },
+    { 9300.0f, 32751.4683f, 5.67942167f, 2.35085165f },
+    { 9320.0f, 32749.1802f, 5.17646656f, 2.39644392f },
+    { 9340.0f, 32742.6202f, 4.67352132f, 2.44203619f },
+    { 9360.0f, 32727.4685f, 4.17058797f, 2.48762847f },
+    { 9380.0f, 32696.9788f, 3.66766305f, 2.53322074f },
+    { 9400.0f, 32641.4501f, 3.16474325f, 2.57881302f },
+    { 9420.0f, 32547.8861f, 2.66182297f, 2.62440529f },
+    { 9440.0f, 32399.9451f, 2.1588979f, 2.66999757f },
+    { 9460.0f, 32178.2802f, 1.65596512f, 2.71558984f },
+    { 9480.0f, 31861.3115f, 1.15302348f, 2.76118211f },
+    { 9500.0f, 31426.4381f, 0.650074863f, 2.80677439f },
+    { 9520.0f, 30851.6197f, 0.147121844f, 2.85236666f },
+    { 9540.0f, 30117.1986f, 5.92735361f, 2.89795894f },
+    { 9560.0f, 29207.8109f, 5.4244008f, 2.94355121f },
+    { 9580.0f, 28114.1244f, 4.92145183f, 2.98914349f },
+    { 9600.0f, 26834.3411f, 4.41850709f, 3.03473576f },
+    { 9620.0f, 25374.9521f, 3.91556261f, 3.08032804f },
+    { 9631.875f, 24429.9013f, 3.61708154f, 3.10739832f },
+    { 9632.875f, 24347.2044f, 3.59183023f, 3.10967806f },
+    { 9633.875f, 24265.5819f, 3.56683657f, 3.1119575f },
+    { 9634.875f, 24181.6523f, 3.54162054f, 3.11423721f },
+    { 9635.875f, 24100.0129f, 3.51661332f, 3.11651668f },
+    { 9636.875f, 24014.499f, 3.49153137f, 3.11879625f },
+    { 9637.875f, 23933.4864f, 3.46642986f, 3.12107584f },
+    { 9638.875f, 23845.6361f, 3.44177693f, 3.12335496f },
+    { 9639.875f, 23766.781f, 3.41633177f, 3.12563498f },
+    { 9640.0f, 23755.6362f, 3.41432136f, 3.12591868f },
+    { 9640.875f, 23674.6957f, 3.39318466f, 3.12791256f },
+    { 9641.875f, 23602.7761f, 3.36646459f, 3.13019421f },
+    { 9642.875f, 23500.1495f, 3.35058332f, 3.13246433f },
+    { 9643.875f, 23460.6183f, 3.31739767f, 3.13475489f },
+    { 9644.875f, 23367.8408f, 3.8084946f, 3.13475475f },
+    { 9645.875f, 23275.0633f, 4.29959153f, 3.13475461f },
+    { 9646.875f, 23182.2858f, 4.79068847f, 3.13475446f },
+    { 9647.875f, 23089.5083f, 5.2817854f, 3.13475432f },
+    { 9648.875f, 22996.7308f, 5.77288233f, 3.13475418f },
+    { 9649.875f, 22903.9532f, 6.26397927f, 3.13475404f },
+    { 9650.875f, 22801.2434f, 0.0143557467f, 3.1324626f },
+    { 9651.875f, 22723.6471f, 0.0284936049f, 3.13019442f },
+    { 9652.875f, 22627.0896f, 0.0559815288f, 3.12791184f },
+    { 9653.875f, 22543.1549f, 0.0783462493f, 3.12563513f },
+    { 9654.875f, 22449.4093f, 0.104240778f, 3.12335459f },
+    { 9655.875f, 22362.47f, 0.128480132f, 3.12107592f },
+    { 9656.875f, 22269.8391f, 0.153843533f, 3.11879603f },
+    { 9657.875f, 22181.0924f, 0.178689802f, 3.11651672f },
+    { 9658.875f, 22088.8309f, 0.203852646f, 3.11423708f },
+    { 9659.875f, 21998.8192f, 0.228929852f, 3.11195752f },
+    { 9660.0f, 21987.1485f, 0.231934068f, 3.11167273f },
+    { 9660.875f, 21906.5632f, 0.254015434f, 3.10967797f },
+    { 9661.875f, 21815.5753f, 0.279185216f, 3.10739832f },
+    { 9680.0f, 20112.0677f, 0.734853376f, 3.06608044f },
+    { 9700.0f, 18163.4573f, 1.23778542f, 3.02048818f },
+    { 9720.0f, 16180.6156f, 1.74073641f, 2.9748959f },
+    { 9740.0f, 14204.4062f, 2.24367889f, 2.92930363f },
+    { 9760.0f, 12274.6417f, 2.74660946f, 2.88371135f },
+    { 9780.0f, 10427.9996f, 3.24951625f, 2.83811908f },
+    { 9800.0f, 8696.32897f, 3.75238964f, 2.7925268f },
+    { 9820.0f, 7105.39515f, 4.25522208f, 2.74693453f },
+    { 9840.0f, 5674.14706f, 4.75801512f, 2.70134225f },
+    { 9860.0f, 4414.46433f, 5.26078589f, 2.65574998f },
+    { 9880.0f, 3331.34617f, 5.76357903f, 2.61015771f },
+    { 9900.0f, 2423.44334f, 6.26648554f, 2.56456543f },
+    { 9920.0f, 1683.84078f, 0.486494511f, 2.51897316f },
+    { 9940.0f, 1100.99463f, 0.990318432f, 2.47338088f },
+    { 9960.0f, 659.746206f, 1.49551678f, 2.42778861f },
+    { 9980.0f, 342.354624f, 2.00415327f, 2.38219633f },
+    { 10000.0f, 129.51807f, 2.5258655f, 2.33660406f },
+    { 10020.0f, 3.74129749f, 4.2464134f, 2.29101179f },
+    { 10040.0f, 62.1735903f, 0.316201052f, 2.24541951f },
+    { 10060.0f, 78.9676587f, 0.844312718f, 2.19982724f },
+    { 10080.0f, 65.9916077f, 1.36635528f, 2.15423496f },
+    { 10100.0f, 37.472784f, 1.90943978f, 2.10864269f },
+    { 10120.0f, 5.38160323f, 2.90086517f, 2.06305042f },
+    { 10140.0f, 24.3979038f, 5.87719649f, 2.01745814f },
+    { 10160.0f, 43.9961592f, 0.158729341f, 1.97186586f },
+    { 10180.0f, 52.320239f, 0.685731608f, 1.92627359f },
+    { 10200.0f, 49.595543f, 1.20752701f, 1.88068132f },
+    { 10220.0f, 37.9684324f, 1.73362492f, 1.83508904f },
+    { 10240.0f, 20.7810735f, 2.28370473f, 1.78949677f },
+    { 10260.0f, 2.3300755f, 3.47367472f, 1.74390449f },
+    { 10280.0f, 15.6401094f, 6.28056443f, 1.69831222f },
+    { 10300.0f, 28.3257469f, 0.563307523f, 1.65271994f },
+    { 10320.0f, 34.8284978f, 1.09829969f, 1.60712767f },
+    { 10340.0f, 34.7134816f, 1.6298383f, 1.5615354f },
+    { 10360.0f, 28.7395926f, 2.16651793f, 1.51594312f },
+    { 10380.0f, 18.5928619f, 2.72303787f, 1.47035085f },
+    { 10400.0f, 6.57203119f, 3.40804501f, 1.42475857f },
+    { 10420.0f, 5.64659323f, 0.270848846f, 1.37916631f },
+    { 10440.0f, 14.9424857f, 0.982381429f, 1.33357402f },
+    { 10460.0f, 20.5906364f, 1.55236577f, 1.28798175f },
+    { 10480.0f, 21.8937852f, 2.10985482f, 1.24238948f },
+    { 10500.0f, 19.0840652f, 2.67696676f, 1.1967972f },
+    { 10520.0f, 13.1455589f, 3.28471508f, 1.15120493f },
+    { 10540.0f, 5.7577417f, 4.10637855f, 1.10561266f },
+    { 10560.0f, 3.87747946f, 0.260093376f, 1.06002038f },
+    { 10580.0f, 9.67574344f, 1.29444068f, 1.0144281f },
+    { 10600.0f, 13.5414896f, 1.93891215f, 0.96883583f },
+    { 10620.0f, 14.4212959f, 2.53839826f, 0.923243555f },
+    { 10640.0f, 12.3573852f, 3.15023533f, 0.877651281f },
+    { 10660.0f, 8.09027563f, 3.85100624f, 0.832059007f },
+    { 10680.0f, 3.56828169f, 5.09360295f, 0.786466732f },
+    { 10700.0f, 5.27666511f, 0.761943949f, 0.740874458f },
+    { 10720.0f, 9.45841846f, 1.61860971f, 0.695282186f },
+    { 10740.0f, 11.9576164f, 2.25804324f, 0.649689909f },
+    { 10760.0f, 12.0302521f, 2.85431088f, 0.604097635f },
+    { 10780.0f, 9.70731786f, 3.45922327f, 0.558505361f },
+    { 10800.0f, 5.6195785f, 4.16807034f, 0.512913086f },
+    { 10820.0f, 2.07247942f, 5.90455339f, 0.467320816f },
+    { 10840.0f, 5.53696213f, 1.33599474f, 0.421728545f },
+    { 10860.0f, 9.33861405f, 2.02892735f, 0.376136264f },
+    { 10880.0f, 11.3349926f, 2.60676436f, 0.33054399f },
+    { 10900.0f, 11.0632008f, 3.15539136f, 0.284951715f },
+    { 10920.0f, 8.6000526f, 3.70012332f, 0.239359441f },
+    { 10940.0f, 4.48085047f, 4.28471383f, 0.193767156f },
+    { 10960.0f, 4.92083818f, 3.09694521f, 0.148174883f },
+    { 10980.0f, 5.36082589f, 1.9091766f, 0.10258261f },
+    { 11000.0f, 9.04654246f, 2.45933022f, 0.0569903676f },
+    { 11010.0f, 10.2517601f, 2.71772874f, 0.0341943359f },
+    { 11011.0f, 10.3447977f, 2.74336842f, 0.0319146234f },
+    { 11012.0f, 10.4333143f, 2.76875657f, 0.0296351445f },
+    { 11013.0f, 10.5158084f, 2.79425378f, 0.0273554816f },
+    { 11014.0f, 10.5942944f, 2.81958033f, 0.0250759683f },
+    { 11015.0f, 10.6659182f, 2.84483286f, 0.0227964718f },
+    { 11016.0f, 10.7344961f, 2.87020674f, 0.0205168006f },
+    { 11017.0f, 10.7948526f, 2.89489791f, 0.0182378093f },
+    { 11018.0f, 10.85399f, 2.92059879f, 0.0159576364f },
+    { 11019.0f, 10.9021488f, 2.94358687f, 0.0136803355f },
+    { 11020.0f, 10.9536513f, 2.97059887f, 0.0113983936f },
+    { 11021.0f, 10.9868676f, 2.98587222f, 0.00912896153f },
+    { 11022.0f, 11.0400287f, 3.01926965f, 0.00683798685f },
+    { 11023.0f, 11.0483029f, 2.94979894f, 0.00465419427f },
+    { 11024.0f, 11.8773732f, 3.70504341f, 0.00131959104f },
+    { 11025.0f, 0.987900684f, 1.57079627f, 5.36295678e-11f },
+};
+
+static const TPqfWidebandPoint PqfWidebandTable7[] = {
+    { 1.0f, 3.88950765f, 3.4711872f, 0.00164959346f },
+    { 2.0f, 3.71422921f, 2.99123005f, 0.00465609165f },
+    { 3.0f, 3.7155198f, 3.06182595f, 0.00683817287f },
+    { 4.0f, 3.70387718f, 3.02779691f, 0.00912938391f },
+    { 5.0f, 3.69762699f, 3.0124597f, 0.0113983509f },
+    { 6.0f, 3.68547547f, 2.9848092f, 0.0136805115f },
+    { 7.0f, 3.67414467f, 2.96155853f, 0.0159576068f },
+    { 8.0f, 3.65915999f, 2.9353166f, 0.0182378983f },
+    { 9.0f, 3.64362192f, 2.91031313f, 0.0205167852f },
+    { 10.0f, 3.62523965f, 2.88447574f, 0.0227965227f },
+    { 11.0f, 3.60573986f, 2.85887319f, 0.0250759537f },
+    { 12.0f, 3.58391119f, 2.83312827f, 0.0273555097f },
+    { 13.0f, 3.560524f, 2.80728358f, 0.0296351359f },
+    { 14.0f, 3.53516631f, 2.78149365f, 0.0319146326f },
+    { 15.0f, 3.50814134f, 2.75547817f, 0.0341943346f },
+    { 20.0f, 3.34630202f, 2.62507437f, 0.0455922432f },
+    { 40.0f, 2.30837143f, 2.07180129f, 0.0911845442f },
+    { 60.0f, 1.65611227f, 3.49121391f, 0.136776818f },
+    { 80.0f, 1.00385311f, 4.91062653f, 0.182369091f },
+    { 100.0f, 2.38900199f, 4.14435138f, 0.227961372f },
+    { 120.0f, 3.32941866f, 3.59600903f, 0.273553646f },
+    { 140.0f, 3.59054794f, 3.07809343f, 0.31914592f },
+    { 160.0f, 3.12212269f, 2.55573491f, 0.364738209f },
+    { 180.0f, 2.0375322f, 1.98412746f, 0.410330469f },
+    { 200.0f, 1.60492245f, 3.37029971f, 0.455922731f },
+    { 220.0f, 1.1723127f, 4.75647195f, 0.501514992f },
+    { 240.0f, 2.45360477f, 4.0488809f, 0.547107288f },
+    { 260.0f, 3.25841021f, 3.49100363f, 0.592699553f },
+    { 280.0f, 3.4038253f, 2.94558057f, 0.638291841f },
+    { 300.0f, 2.88264678f, 2.36629037f, 0.683884115f },
+    { 320.0f, 1.87260359f, 1.64978504f, 0.729476398f },
+    { 340.0f, 1.75329592f, 0.166754911f, 0.775068668f },
+    { 360.0f, 1.63398824f, 4.96691009f, 0.820660938f },
+    { 380.0f, 2.66783735f, 4.16742283f, 0.866253214f },
+    { 400.0f, 3.29112335f, 3.5316358f, 0.911845487f },
+    { 420.0f, 3.32741423f, 2.90471553f, 0.957437761f },
+    { 440.0f, 2.83371231f, 2.20107648f, 1.00303002f },
+    { 460.0f, 2.1552114f, 1.27428685f, 1.04862232f },
+    { 480.0f, 2.04996753f, 0.0518351462f, 1.09421458f },
+    { 500.0f, 2.76418805f, 5.29865103f, 1.13980686f },
+    { 520.0f, 3.56051202f, 4.53630829f, 1.18539913f },
+    { 540.0f, 3.93763948f, 3.87640798f, 1.23099141f },
+    { 560.0f, 3.71811669f, 3.22062223f, 1.27658368f },
+    { 580.0f, 2.98196786f, 2.46968477f, 1.32217596f },
+    { 600.0f, 2.21534032f, 1.42394011f, 1.36776823f },
+    { 620.0f, 2.45015038f, 0.126045042f, 1.41336052f },
+    { 640.0f, 3.59925743f, 5.45872512f, 1.45895277f },
+    { 660.0f, 4.70305134f, 4.75951735f, 1.50454505f },
+    { 680.0f, 5.25579956f, 4.14682656f, 1.55013733f },
+    { 700.0f, 5.0476951f, 3.55072122f, 1.5957296f },
+    { 720.0f, 4.08757253f, 2.91394904f, 1.64132188f },
+    { 740.0f, 2.66024608f, 2.09712236f, 1.68691415f },
+    { 760.0f, 1.81816644f, 0.676263246f, 1.73250641f },
+    { 780.0f, 2.88261241f, 5.63003631f, 1.7780987f },
+    { 800.0f, 4.3481222f, 4.85417741f, 1.82369097f },
+    { 820.0f, 5.27629801f, 4.23187958f, 1.86928326f },
+    { 840.0f, 5.37105895f, 3.64656516f, 1.91487552f },
+    { 860.0f, 4.59999599f, 3.04661429f, 1.96046778f },
+    { 880.0f, 3.16845397f, 2.35112667f, 2.00606008f },
+    { 900.0f, 1.70983676f, 1.22702467f, 2.05165235f },
+    { 920.0f, 1.99389658f, 5.82252714f, 2.09724463f },
+    { 940.0f, 3.34071919f, 4.89648883f, 2.1428369f },
+    { 960.0f, 4.24877892f, 4.2451692f, 2.18842917f },
+    { 980.0f, 4.34728716f, 3.65684974f, 2.23402144f },
+    { 1000.0f, 3.60490971f, 3.06675397f, 2.27961372f },
+    { 1020.0f, 2.22322642f, 2.38443532f, 2.32520599f },
+    { 1040.0f, 1.99183912f, 3.88283404f, 2.37079829f },
+    { 1060.0f, 1.76045183f, 5.38123277f, 2.41639058f },
+    { 1080.0f, 3.03811633f, 4.64586627f, 2.46198281f },
+    { 1100.0f, 3.68952017f, 4.07157078f, 2.50757509f },
+    { 1120.0f, 3.53263387f, 3.53969854f, 2.55316736f },
+    { 1140.0f, 2.61032783f, 3.02746103f, 2.59875964f },
+    { 1160.0f, 1.1406686f, 2.5417664f, 2.64435191f },
+    { 1180.0f, 1.60225585f, 3.57445616f, 2.68994419f },
+    { 1200.0f, 2.06384309f, 4.60714591f, 2.73553646f },
+    { 1220.0f, 3.09028893f, 4.11299942f, 2.78112875f },
+    { 1240.0f, 3.40802807f, 3.61464374f, 2.82672099f },
+    { 1260.0f, 2.96211473f, 3.11804109f, 2.87231328f },
+    { 1280.0f, 1.86458062f, 2.6356709f, 2.91790557f },
+    { 1300.0f, 1.54487425f, 3.61065524f, 2.96349784f },
+    { 1320.0f, 1.22516788f, 4.58563957f, 3.00909011f },
+    { 1340.0f, 2.5436647f, 4.11627846f, 3.0546824f },
+    { 1360.0f, 3.34305691f, 3.59893506f, 3.10027459f },
+    { 1363.125f, 3.40959169f, 3.51613923f, 3.10739832f },
+    { 1364.125f, 3.42720077f, 3.48944128f, 3.10967803f },
+    { 1365.125f, 3.44335461f, 3.46289836f, 3.1119575f },
+    { 1366.125f, 3.45743042f, 3.43617842f, 3.11423713f },
+    { 1367.125f, 3.47017956f, 3.4094751f, 3.11651668f },
+    { 1368.125f, 3.48068651f, 3.38282398f, 3.11879613f },
+    { 1369.125f, 3.49011919f, 3.35582856f, 3.12107589f },
+    { 1370.125f, 3.49687293f, 3.32964727f, 3.12335472f },
+    { 1371.125f, 3.50317394f, 3.30208442f, 3.12563505f },
+    { 1372.125f, 3.50603225f, 3.27752398f, 3.12791208f },
+    { 1373.125f, 3.50961547f, 3.24837854f, 3.13019432f },
+    { 1374.125f, 3.50783716f, 3.23168489f, 3.13246309f },
+    { 1375.125f, 3.51045843f, 3.19606912f, 3.13475437f },
+    { 1376.125f, 3.50322568f, 2.68271848f, 3.13475442f },
+    { 1377.125f, 3.49599293f, 2.16936784f, 3.13475447f },
+    { 1378.125f, 3.48876017f, 1.65601719f, 3.13475451f },
+    { 1379.125f, 3.48152742f, 1.14266655f, 3.13475456f },
+    { 1380.0f, 3.47519876f, 0.693484739f, 3.1347546f },
+    { 1380.125f, 3.47429467f, 0.629315909f, 3.13475461f },
+    { 1381.125f, 3.46706192f, 0.115965266f, 3.13475465f },
+    { 1382.125f, 3.44813573f, 0.151957245f, 3.13246364f },
+    { 1383.125f, 3.43526683f, 0.169791729f, 3.13019425f },
+    { 1384.125f, 3.41670659f, 0.199425553f, 3.12791234f },
+    { 1385.125f, 3.39922084f, 0.225133513f, 3.12563502f },
+    { 1386.125f, 3.37834622f, 0.253569585f, 3.12335486f },
+    { 1387.125f, 3.35706721f, 0.281070347f, 3.12107585f },
+    { 1388.125f, 3.33333335f, 0.309280824f, 3.11879619f },
+    { 1389.125f, 3.30865921f, 0.337467908f, 3.11651667f },
+    { 1390.125f, 3.28193098f, 0.365727276f, 3.11423719f },
+    { 1391.125f, 3.25396497f, 0.394252601f, 3.11195752f },
+    { 1392.125f, 3.22417086f, 0.422715671f, 3.10967805f },
+    { 1393.125f, 3.19310573f, 0.451525014f, 3.10739832f },
+    { 1400.0f, 2.93912915f, 0.652328235f, 3.0917261f },
+    { 1420.0f, 1.87612182f, 1.30355878f, 3.04613383f },
+    { 1440.0f, 1.55020848f, 6.18541324f, 3.00054156f },
+    { 1460.0f, 1.22429514f, 4.78408239f, 2.95494929f },
+    { 1480.0f, 2.42809693f, 5.584394f, 2.90935701f },
+    { 1500.0f, 3.28491627f, 6.22027288f, 2.86376473f },
+    { 1520.0f, 3.64483141f, 0.546283833f, 2.81817247f },
+    { 1540.0f, 3.48047007f, 1.15738734f, 2.77258018f },
+    { 1560.0f, 2.84794335f, 1.7899535f, 2.72698791f },
+    { 1580.0f, 1.87030721f, 2.49396159f, 2.68139564f },
+    { 1600.0f, 1.44057039f, 0.999941577f, 2.63580336f },
+    { 1620.0f, 1.01083357f, 5.78910687f, 2.59021109f },
+    { 1640.0f, 2.1229538f, 0.4298231f, 2.54461881f },
+    { 1660.0f, 3.08236147f, 1.0708218f, 2.49902654f },
+    { 1680.0f, 3.6824734f, 1.63564402f, 2.45343426f },
+    { 1700.0f, 3.81752627f, 2.15461591f, 2.40784199f },
+    { 1720.0f, 3.45158807f, 2.62727378f, 2.36224972f },
+    { 1740.0f, 2.63249166f, 3.02678349f, 2.31665744f },
+    { 1760.0f, 1.53147993f, 3.22064746f, 2.27106517f },
+    { 1780.0f, 1.69375077f, 2.64070578f, 2.22547289f },
+    { 1800.0f, 1.85602161f, 2.0607641f, 2.17988062f },
+    { 1820.0f, 3.04084732f, 2.2640161f, 2.13428834f },
+    { 1840.0f, 3.95909051f, 2.57229634f, 2.08869607f },
+    { 1860.0f, 4.47101798f, 2.89222913f, 2.04310379f },
+    { 1880.0f, 4.53444886f, 3.19311281f, 1.99751151f },
+    { 1900.0f, 4.18492595f, 3.45021091f, 1.95191925f },
+    { 1920.0f, 3.54534984f, 3.62382068f, 1.90632697f },
+    { 1940.0f, 2.8764089f, 3.64231201f, 1.86073468f },
+    { 1960.0f, 2.63124683f, 3.47224021f, 1.81514242f },
+    { 1980.0f, 3.08726937f, 3.3277667f, 1.76955015f },
+    { 2000.0f, 3.90162128f, 3.37219404f, 1.72395787f },
+    { 2020.0f, 4.63441177f, 3.54276105f, 1.6783656f },
+    { 2040.0f, 5.03175832f, 3.76658505f, 1.63277332f },
+    { 2060.0f, 4.99403652f, 3.99709675f, 1.58718105f },
+    { 2080.0f, 4.56160142f, 4.19462872f, 1.54158878f },
+    { 2100.0f, 3.92215812f, 4.31336158f, 1.4959965f },
+    { 2120.0f, 3.39755187f, 4.31583811f, 1.45040423f },
+    { 2140.0f, 3.27832283f, 4.24986596f, 1.40481195f },
+    { 2160.0f, 3.50407364f, 4.24071248f, 1.35921968f },
+    { 2180.0f, 3.75494842f, 4.32246002f, 1.31362739f },
+    { 2200.0f, 3.81830032f, 4.44631055f, 1.26803513f },
+    { 2220.0f, 3.69562473f, 4.55919013f, 1.22244286f },
+    { 2240.0f, 3.53969542f, 4.63544325f, 1.17685058f },
+    { 2260.0f, 3.49873865f, 4.69915898f, 1.13125831f },
+    { 2280.0f, 3.54105771f, 4.80333905f, 1.08566603f },
+    { 2300.0f, 3.47340105f, 4.96715031f, 1.04007376f },
+    { 2320.0f, 3.12135992f, 5.16030182f, 0.994481485f },
+    { 2340.0f, 2.46610833f, 5.30652335f, 0.94888921f },
+    { 2360.0f, 1.76252076f, 5.23240082f, 0.90329697f },
+    { 2380.0f, 1.68906903f, 4.85329983f, 0.857704661f },
+    { 2400.0f, 2.37121471f, 4.75397444f, 0.812112387f },
+    { 2420.0f, 3.08286913f, 4.96909681f, 0.766520117f },
+    { 2440.0f, 3.41290781f, 5.3153188f, 0.720927832f },
+    { 2460.0f, 3.21496923f, 5.7206113f, 0.675335564f },
+    { 2480.0f, 2.4988317f, 6.15505587f, 0.629743302f },
+    { 2500.0f, 1.39089323f, 0.308155055f, 0.584151015f },
+    { 2520.0f, 1.28248127f, 5.58654644f, 0.538558722f },
+    { 2540.0f, 1.17406931f, 4.58175252f, 0.492966429f },
+    { 2560.0f, 2.17547756f, 5.05594579f, 0.447374199f },
+    { 2580.0f, 2.7680317f, 5.57071304f, 0.401781916f },
+    { 2600.0f, 2.87746583f, 6.10718845f, 0.356189644f },
+    { 2620.0f, 2.51790506f, 0.384830668f, 0.310597369f },
+    { 2640.0f, 1.78261337f, 0.992530667f, 0.265005093f },
+    { 2660.0f, 1.6339402f, 0.326184022f, 0.219412819f },
+    { 2680.0f, 1.48526703f, 5.94302268f, 0.173820545f },
+    { 2700.0f, 1.33659386f, 5.27667604f, 0.128228271f },
+    { 2720.0f, 2.04492199f, 5.92555163f, 0.0826360064f },
+    { 2740.0f, 2.41714543f, 0.215623641f, 0.037043818f },
+    { 2741.25f, 2.42741617f, 0.250237035f, 0.0341942302f },
+    { 2742.25f, 2.43443388f, 0.277590405f, 0.0319148216f },
+    { 2743.25f, 2.44056512f, 0.305256464f, 0.0296349776f },
+    { 2744.25f, 2.44552751f, 0.332316503f, 0.0273557275f },
+    { 2745.25f, 2.44956306f, 0.359987939f, 0.025075695f },
+    { 2746.25f, 2.45249936f, 0.386592763f, 0.0227967692f },
+    { 2747.25f, 2.45443156f, 0.414408439f, 0.0205163914f },
+    { 2748.25f, 2.45535332f, 0.440277139f, 0.0182380978f },
+    { 2749.25f, 2.45503374f, 0.46853636f, 0.0159570092f },
+    { 2750.25f, 2.4540682f, 0.492855996f, 0.0136802271f },
+    { 2751.25f, 2.45078072f, 0.5221438f, 0.0113976268f },
+    { 2752.25f, 2.44856556f, 0.541839669f, 0.00912565905f },
+    { 2753.25f, 2.43700132f, 0.571631714f, 0.00684085098f },
+    { 2754.25f, 2.43857049f, 0.556605162f, 0.00460439173f },
+    { 2755.25f, 2.4310245f, 1.02392938f, 0.0045947166f },
+    { 2756.25f, 2.4234785f, 1.49125359f, 0.00458504146f },
+    { 2757.25f, 2.4159325f, 1.9585778f, 0.00457536632f },
+    { 2758.25f, 2.4083865f, 2.42590202f, 0.00456569118f },
+    { 2759.25f, 2.40730961f, 2.40992118f, 0.00683658077f },
+    { 2760.0f, 2.39420858f, 2.39274281f, 0.0085432934f },
+    { 2760.25f, 2.38713699f, 2.3826969f, 0.00911687183f },
+    { 2761.25f, 2.37656095f, 2.35490679f, 0.0113986477f },
+    { 2762.25f, 2.36163274f, 2.3303593f, 0.0136766025f },
+    { 2763.25f, 2.34785662f, 2.30318205f, 0.0159577347f },
+    { 2764.25f, 2.33213306f, 2.27841138f, 0.0182362108f },
+    { 2765.25f, 2.31611807f, 2.25188256f, 0.0205167951f },
+    { 2766.25f, 2.29879677f, 2.22693127f, 0.0227956961f },
+    { 2767.25f, 2.28071178f, 2.20091893f, 0.0250759008f },
+    { 2768.25f, 2.26164519f, 2.17593569f, 0.0273550819f },
+    { 2769.25f, 2.2416323f, 2.15033667f, 0.0296350701f },
+    { 2770.25f, 2.22070526f, 2.1253793f, 0.0319144189f },
+    { 2771.25f, 2.19885689f, 2.10013021f, 0.0341942547f },
+    { 2780.0f, 1.97020112f, 1.88630878f, 0.0541408315f },
+    { 2800.0f, 1.23611171f, 1.46218966f, 0.0997330918f },
+    { 2820.0f, 1.34468106f, 1.88417968f, 0.145325376f },
+    { 2840.0f, 1.4532504f, 2.30616969f, 0.190917661f },
+    { 2860.0f, 1.56181975f, 2.7281597f, 0.236509945f },
+    { 2880.0f, 2.08394133f, 2.35598696f, 0.282102197f },
+    { 2900.0f, 2.24546089f, 2.00253126f, 0.327694472f },
+    { 2920.0f, 2.07380989f, 1.72624799f, 0.373286765f },
+    { 2940.0f, 1.73934355f, 1.605147f, 0.41887902f },
+    { 2960.0f, 1.5587153f, 1.68563322f, 0.464471346f },
+    { 2980.0f, 1.71939785f, 1.77555069f, 0.510063532f },
+    { 3000.0f, 1.98203915f, 1.71310394f, 0.555655843f },
+    { 3020.0f, 2.07019123f, 1.58084725f, 0.601248126f },
+    { 3040.0f, 1.93911247f, 1.50662259f, 0.646840383f },
+    { 3060.0f, 1.83085258f, 1.59573731f, 0.692432667f },
+    { 3080.0f, 2.12310896f, 1.73714062f, 0.738024941f },
+    { 3100.0f, 2.75664932f, 1.69899651f, 0.783617215f },
+    { 3120.0f, 3.33216759f, 1.50270192f, 0.829209489f },
+    { 3140.0f, 3.5290645f, 1.23745019f, 0.874801749f },
+    { 3160.0f, 3.18818858f, 0.973090621f, 0.920394045f },
+    { 3180.0f, 2.35194236f, 0.816564039f, 0.965986314f },
+    { 3200.0f, 1.52237504f, 1.10837971f, 1.01157859f },
+    { 3220.0f, 2.060125f, 1.70111722f, 1.05717086f },
+    { 3240.0f, 3.46198501f, 1.67198584f, 1.10276314f },
+    { 3260.0f, 4.69055911f, 1.40692325f, 1.14835543f },
+    { 3280.0f, 5.33021863f, 1.07600977f, 1.19394768f },
+    { 3300.0f, 5.18660247f, 0.732909699f, 1.23953996f },
+    { 3320.0f, 4.24159719f, 0.419132668f, 1.28513222f },
+    { 3340.0f, 2.69423601f, 0.242915342f, 1.33072451f },
+    { 3360.0f, 1.43791433f, 0.778615415f, 1.37631678f },
+    { 3380.0f, 2.61441565f, 1.44289262f, 1.42190907f },
+    { 3400.0f, 4.46646633f, 1.29816783f, 1.46750133f },
+    { 3420.0f, 5.8685092f, 0.987120001f, 1.5130936f },
+    { 3440.0f, 6.4880357f, 0.635188224f, 1.55868588f },
+    { 3460.0f, 6.20256801f, 0.27945742f, 1.60427816f },
+    { 3480.0f, 5.06372786f, 6.23410401f, 1.64987043f },
+    { 3500.0f, 3.31389666f, 6.01194378f, 1.6954627f },
+    { 3520.0f, 1.66854365f, 0.025942654f, 1.74105495f },
+    { 3540.0f, 2.32292517f, 0.849944207f, 1.78664725f },
+    { 3560.0f, 4.09972312f, 0.788523503f, 1.83223953f },
+    { 3580.0f, 5.48247229f, 0.491519762f, 1.87783179f },
+    { 3600.0f, 6.11968686f, 0.135478184f, 1.92342407f },
+    { 3620.0f, 5.91303623f, 6.0466721f, 1.96901634f },
+    { 3640.0f, 4.92658148f, 5.68335412f, 2.01460862f },
+    { 3660.0f, 3.36557654f, 5.37363925f, 2.0602009f },
+    { 3680.0f, 1.62848179f, 5.33747663f, 2.10579316f },
+    { 3700.0f, 1.28751247f, 0.107838623f, 2.15138545f },
+    { 3720.0f, 2.67441484f, 0.22899958f, 2.19697772f },
+    { 3740.0f, 3.82561083f, 6.20320636f, 2.24256999f },
+    { 3760.0f, 4.39011915f, 5.8041766f, 2.28816227f },
+    { 3780.0f, 4.31273063f, 5.36777046f, 2.33375454f },
+    { 3800.0f, 3.66437024f, 4.90642845f, 2.37934682f },
+    { 3820.0f, 2.60085191f, 4.42008467f, 2.42493909f },
+    { 3840.0f, 1.32291039f, 3.88986639f, 2.47053137f },
+    { 3860.0f, 1.22416938f, 5.01637962f, 2.51612363f },
+    { 3880.0f, 1.12542837f, 6.14289285f, 2.5617159f },
+    { 3900.0f, 2.01887934f, 5.54308483f, 2.60730819f },
+    { 3920.0f, 2.62734553f, 4.94614161f, 2.65290046f },
+    { 3940.0f, 2.95988359f, 4.33548004f, 2.69849273f },
+    { 3960.0f, 3.03644479f, 3.71544431f, 2.74408501f },
+    { 3980.0f, 2.85432303f, 3.09375683f, 2.78967729f },
+    { 4000.0f, 2.38422581f, 2.47230774f, 2.83526956f },
+    { 4020.0f, 1.60054229f, 1.82689617f, 2.88086183f },
+    { 4040.0f, 1.8311002f, 2.44555779f, 2.92645411f },
+    { 4060.0f, 2.06165812f, 3.06421942f, 2.97204638f },
+    { 4080.0f, 2.29221604f, 3.68288104f, 3.01763866f },
+    { 4100.0f, 3.53734481f, 3.11917132f, 3.06323092f },
+    { 4119.375f, 4.38130454f, 2.61070917f, 3.1073985f },
+    { 4120.0f, 4.40020527f, 2.59464211f, 3.10882327f },
+    { 4120.375f, 4.41124467f, 2.58523012f, 3.10967787f },
+    { 4121.375f, 4.43972125f, 2.55932664f, 3.11195777f },
+    { 4122.375f, 4.46666867f, 2.53406908f, 3.11423699f },
+    { 4123.375f, 4.49197015f, 2.50808418f, 3.11651707f },
+    { 4124.375f, 4.51581611f, 2.48308327f, 3.11879608f },
+    { 4125.375f, 4.53773375f, 2.45696858f, 3.1210764f },
+    { 4126.375f, 4.55862029f, 2.43237032f, 3.12335505f },
+    { 4127.375f, 4.57663667f, 2.40595328f, 3.1256358f },
+    { 4128.375f, 4.59492483f, 2.38189504f, 3.1279139f },
+    { 4129.375f, 4.60725637f, 2.35513902f, 3.13019517f },
+    { 4130.375f, 4.62452412f, 2.33155175f, 3.13247264f },
+    { 4131.375f, 4.61955378f, 2.30754888f, 3.13475141f },
+    { 4132.375f, 4.64785261f, 2.2716126f, 3.13704001f },
+    { 4133.375f, 4.65471297f, 1.9327989f, 3.13705008f },
+    { 4134.375f, 4.66157332f, 1.5939852f, 3.13706016f },
+    { 4135.375f, 4.66843368f, 1.2551715f, 3.13707024f },
+    { 4136.375f, 4.67529403f, 0.916357797f, 3.13708031f },
+    { 4137.375f, 4.68880819f, 0.983779383f, 3.13475576f },
+    { 4138.375f, 4.67446429f, 1.005779f, 3.13248127f },
+    { 4139.375f, 4.67443372f, 1.03774945f, 3.13019414f },
+    { 4140.0f, 4.67089623f, 1.0538161f, 3.12876907f },
+    { 4140.375f, 4.6684538f, 1.06036453f, 3.12791747f },
+    { 4141.375f, 4.66317164f, 1.08790047f, 3.12563507f },
+    { 4142.375f, 4.65526715f, 1.11162044f, 3.12335691f },
+    { 4143.375f, 4.6459608f, 1.13775753f, 3.12107598f },
+    { 4144.375f, 4.63477428f, 1.16199598f, 3.11879715f },
+    { 4145.375f, 4.62164116f, 1.18751171f, 3.11651684f },
+    { 4146.375f, 4.60684475f, 1.21199198f, 3.11423765f },
+    { 4147.375f, 4.58997479f, 1.23715469f, 3.11195767f },
+    { 4148.375f, 4.5714071f, 1.26176258f, 3.10967828f },
+    { 4149.375f, 4.55079418f, 1.28672956f, 3.10739846f },
+    { 4160.0f, 4.21634749f, 1.54838839f, 3.08317759f },
+    { 4180.0f, 3.03169921f, 2.03135973f, 3.03758527f },
+    { 4200.0f, 1.24604142f, 2.47163306f, 2.991993f },
+    { 4220.0f, 2.13607062f, 1.44819434f, 2.94640074f },
+    { 4240.0f, 3.02609981f, 0.424755631f, 2.90080847f },
+    { 4260.0f, 4.77696342f, 0.900260324f, 2.85521618f },
+    { 4280.0f, 5.81146591f, 1.3856636f, 2.80962391f },
+    { 4300.0f, 5.90408984f, 1.87670319f, 2.76403163f },
+    { 4320.0f, 4.993144f, 2.37460627f, 2.71843936f },
+    { 4340.0f, 3.20252435f, 2.88799219f, 2.67284708f },
+    { 4360.0f, 2.47159964f, 1.7461653f, 2.62725481f },
+    { 4380.0f, 1.74067494f, 0.60433841f, 2.58166253f },
+    { 4400.0f, 4.00531791f, 1.16602552f, 2.53607026f },
+    { 4420.0f, 5.57811968f, 1.69516651f, 2.49047798f },
+    { 4440.0f, 6.17213987f, 2.22950011f, 2.44488571f },
+    { 4460.0f, 5.68990764f, 2.78416024f, 2.39929344f },
+    { 4480.0f, 4.25158457f, 3.39150208f, 2.35370116f },
+    { 4500.0f, 2.24283061f, 4.20691267f, 2.30810889f },
+    { 4520.0f, 1.33937461f, 6.20287378f, 2.26251661f },
+    { 4540.0f, 3.13155794f, 1.19832797f, 2.21692435f },
+    { 4560.0f, 4.7763217f, 1.91057261f, 2.17133207f },
+    { 4580.0f, 5.63102287f, 2.5524053f, 2.12573979f },
+    { 4600.0f, 5.56909578f, 3.20564091f, 2.08014752f },
+    { 4620.0f, 4.72149523f, 3.92632388f, 2.03455524f },
+    { 4640.0f, 3.51408519f, 4.82009635f, 1.98896297f },
+    { 4660.0f, 2.83264876f, 6.03319269f, 1.94337069f },
+    { 4680.0f, 3.40135438f, 0.9740705f, 1.89777842f },
+    { 4700.0f, 4.44305956f, 1.90405379f, 1.85218615f },
+    { 4720.0f, 5.16736911f, 2.6899486f, 1.80659388f },
+    { 4740.0f, 5.31033519f, 3.44327656f, 1.7610016f },
+    { 4760.0f, 4.90293745f, 4.22729071f, 1.71540932f },
+    { 4780.0f, 4.19182156f, 5.10274365f, 1.66981705f },
+    { 4800.0f, 3.62388848f, 6.12470389f, 1.62422477f },
+    { 4820.0f, 3.65864581f, 0.945739208f, 1.57863249f },
+    { 4840.0f, 4.25116206f, 1.95123995f, 1.53304023f },
+    { 4860.0f, 4.94414338f, 2.81822256f, 1.48744795f },
+    { 4880.0f, 5.36502627f, 3.60039461f, 1.44185568f },
+    { 4900.0f, 5.31414877f, 4.34515851f, 1.3962634f },
+    { 4920.0f, 4.72664749f, 5.09242713f, 1.35067113f },
+    { 4940.0f, 3.68505804f, 5.90598019f, 1.30507886f },
+    { 4960.0f, 2.55987598f, 0.668139504f, 1.25948656f },
+    { 4980.0f, 2.37284748f, 2.08562912f, 1.2138943f },
+    { 5000.0f, 3.48526846f, 3.22839588f, 1.16830203f },
+    { 5020.0f, 4.78687431f, 4.02574515f, 1.12270975f },
+    { 5040.0f, 5.612304f, 4.68650603f, 1.07711748f },
+    { 5060.0f, 5.65949087f, 5.28778887f, 1.0315252f },
+    { 5080.0f, 4.82722381f, 5.86001465f, 0.985932937f },
+    { 5100.0f, 3.19357539f, 0.143422525f, 0.940340658f },
+    { 5120.0f, 1.00958372f, 0.830499264f, 0.894748403f },
+    { 5140.0f, 1.45184591f, 4.08232457f, 0.849156111f },
+    { 5160.0f, 3.65379551f, 4.68116856f, 0.803563835f },
+    { 5180.0f, 5.27710082f, 5.19050522f, 0.757971561f },
+    { 5200.0f, 6.02276853f, 5.67454607f, 0.712379286f },
+    { 5220.0f, 5.75365132f, 6.13748221f, 0.666787012f },
+    { 5240.0f, 4.51873295f, 0.283858461f, 0.621194734f },
+    { 5260.0f, 2.56649342f, 0.610013564f, 0.57560246f },
+    { 5280.0f, 2.52453943f, 6.10075928f, 0.530010188f },
+    { 5300.0f, 2.48258544f, 5.30831968f, 0.484417915f },
+    { 5320.0f, 4.35543918f, 5.6125214f, 0.43882564f },
+    { 5340.0f, 5.47902395f, 6.01043072f, 0.393233366f },
+    { 5360.0f, 5.62698236f, 0.140243494f, 0.34764109f },
+    { 5380.0f, 4.77916657f, 0.541233391f, 0.302048817f },
+    { 5400.0f, 3.11578389f, 0.879709593f, 0.256456543f },
+    { 5420.0f, 1.14701764f, 0.749744727f, 0.210864283f },
+    { 5440.0f, 1.82550782f, 5.68160403f, 0.165271982f },
+    { 5460.0f, 3.76351015f, 5.86441269f, 0.119679723f },
+    { 5480.0f, 5.1099072f, 6.24473758f, 0.0740874729f },
+    { 5497.5f, 5.54548814f, 0.329922181f, 0.0341942088f },
+    { 5498.5f, 5.54714316f, 0.351241575f, 0.0319148067f },
+    { 5499.5f, 5.5464157f, 0.373007629f, 0.0296349511f },
+    { 5500.0f, 5.54486463f, 0.383686995f, 0.0284952514f },
+    { 5500.5f, 5.54294917f, 0.394227781f, 0.0273557325f },
+    { 5501.5f, 5.5370662f, 0.416240006f, 0.0250756687f },
+    { 5502.5f, 5.52855042f, 0.437250701f, 0.0227967601f },
+    { 5503.5f, 5.51746833f, 0.459605924f, 0.0205163606f },
+    { 5504.5f, 5.50397905f, 0.480122211f, 0.0182380532f },
+    { 5505.5f, 5.48732054f, 0.503088174f, 0.0159569881f },
+    { 5506.5f, 5.46920421f, 0.522341233f, 0.0136801076f },
+    { 5507.5f, 5.44542114f, 0.546503086f, 0.0113975971f },
+    { 5508.5f, 5.42418457f, 0.561520969f, 0.00912531091f },
+    { 5509.5f, 5.38152017f, 0.586129339f, 0.00684090501f },
+    { 5510.5f, 5.36832244f, 0.568082095f, 0.00460268185f },
+    { 5511.5f, 5.33407977f, 1.03420113f, 0.00459387705f },
+    { 5512.5f, 5.2998371f, 1.50032017f, 0.00458507225f },
+    { 5513.5f, 5.26559443f, 1.96643921f, 0.00457626745f },
+    { 5514.5f, 5.23135176f, 2.43255825f, 0.00456746265f },
+    { 5515.5f, 5.21060575f, 2.42257767f, 0.00683657857f },
+    { 5516.5f, 5.14817687f, 2.39923432f, 0.00911727497f },
+    { 5517.5f, 5.10641987f, 2.37593225f, 0.0113986536f },
+    { 5518.5f, 5.05496214f, 2.35531539f, 0.0136767445f },
+    { 5519.5f, 5.00592831f, 2.33217304f, 0.0159577534f },
+    { 5520.0f, 4.9789104f, 2.32110946f, 0.0170976483f },
+    { 5520.5f, 4.95238063f, 2.31118038f, 0.0182363011f },
+    { 5521.5f, 4.89804332f, 2.28845612f, 0.0205168135f },
+    { 5522.5f, 4.84075637f, 2.26715834f, 0.0227957194f },
+    { 5523.5f, 4.78171667f, 2.24470991f, 0.0250759203f },
+    { 5524.5f, 4.72019774f, 2.22318634f, 0.0273550898f },
+    { 5525.5f, 4.65674868f, 2.20094995f, 0.0296350868f },
+    { 5526.5f, 4.59110737f, 2.17932394f, 0.0319143942f },
+    { 5527.5f, 4.52329766f, 2.15721344f, 0.0341942658f },
+    { 5540.0f, 3.51333554f, 1.8867403f, 0.0626893492f },
+    { 5560.0f, 1.42383555f, 1.51743755f, 0.108281601f },
+    { 5580.0f, 2.27736482f, 2.49507758f, 0.153873901f },
+    { 5600.0f, 3.13089409f, 3.4727176f, 0.199466201f },
+    { 5620.0f, 4.75293407f, 3.00000235f, 0.245058466f },
+    { 5640.0f, 5.55844387f, 2.49023907f, 0.290650749f },
+    { 5660.0f, 5.45210278f, 1.9414151f, 0.336243024f },
+    { 5680.0f, 4.54045856f, 1.32499538f, 0.381835289f },
+    { 5700.0f, 3.16420365f, 0.550312981f, 0.427427572f },
+    { 5720.0f, 2.09781369f, 5.64263523f, 0.47301986f },
+    { 5740.0f, 2.45567714f, 4.2353825f, 0.518612121f },
+    { 5760.0f, 3.50540352f, 3.25535967f, 0.564204395f },
+    { 5780.0f, 4.32943435f, 2.45052222f, 0.609796676f },
+    { 5800.0f, 4.78947765f, 1.66152377f, 0.655388944f },
+    { 5820.0f, 5.06079357f, 0.844561177f, 0.700981219f },
+    { 5840.0f, 5.3447218f, 0.0163666918f, 0.74657349f },
+    { 5860.0f, 5.61592777f, 5.49857736f, 0.792165768f },
+    { 5880.0f, 5.61328026f, 4.73366621f, 0.837758041f },
+    { 5900.0f, 5.07254016f, 3.96623225f, 0.883350315f },
+    { 5920.0f, 4.01213566f, 3.08854549f, 0.928942588f },
+    { 5940.0f, 3.22540431f, 1.87891232f, 0.974534864f },
+    { 5960.0f, 4.2400154f, 0.583649773f, 1.02012714f },
+    { 5980.0f, 6.46555738f, 5.97172626f, 1.06571941f },
+    { 6000.0f, 8.5564652f, 5.28756064f, 1.11131169f },
+    { 6020.0f, 9.72999299f, 4.68327193f, 1.15690396f },
+    { 6040.0f, 9.5269824f, 4.10669153f, 1.20249624f },
+    { 6060.0f, 7.78596783f, 3.51972889f, 1.24808851f },
+    { 6080.0f, 4.72334227f, 2.82607901f, 1.29368077f },
+    { 6100.0f, 1.95340957f, 1.19462354f, 1.33927306f },
+    { 6120.0f, 4.96855536f, 5.78594664f, 1.38486533f },
+    { 6140.0f, 8.96209995f, 5.10253833f, 1.4304576f },
+    { 6160.0f, 11.877607f, 4.54885078f, 1.47604988f },
+    { 6180.0f, 13.0142494f, 4.03039471f, 1.52164216f },
+    { 6200.0f, 12.0396679f, 3.52450541f, 1.56723443f },
+    { 6220.0f, 9.00773625f, 3.01856941f, 1.6128267f },
+    { 6240.0f, 4.3660192f, 2.47776037f, 1.65841898f },
+    { 6260.0f, 1.2502374f, 5.60585592f, 1.70401125f },
+    { 6280.0f, 6.5918378f, 4.82540244f, 1.74960353f },
+    { 6300.0f, 10.9204313f, 4.31938002f, 1.7951958f },
+    { 6320.0f, 13.3697474f, 3.83516431f, 1.84078808f },
+    { 6340.0f, 13.4576787f, 3.36175404f, 1.88638035f },
+    { 6360.0f, 11.1391186f, 2.90261354f, 1.93197263f },
+    { 6380.0f, 6.83657796f, 2.48515143f, 1.97756489f },
+    { 6400.0f, 1.59110111f, 2.55667119f, 2.02315717f },
+    { 6420.0f, 4.59873481f, 4.30386609f, 2.06874945f },
+    { 6440.0f, 9.32169311f, 3.94695488f, 2.11434172f },
+    { 6460.0f, 12.2473805f, 3.50785314f, 2.159934f },
+    { 6480.0f, 12.7761716f, 3.05776085f, 2.20552627f },
+    { 6500.0f, 10.8124196f, 2.61863775f, 2.25111855f },
+    { 6520.0f, 6.7867781f, 2.23790728f, 2.29671082f },
+    { 6540.0f, 1.99977365f, 2.45273763f, 2.34230309f },
+    { 6560.0f, 4.6941105f, 3.84453762f, 2.38789536f },
+    { 6580.0f, 9.26303907f, 3.54431105f, 2.43348764f },
+    { 6600.0f, 12.0957669f, 3.11538344f, 2.47907992f },
+    { 6620.0f, 12.540906f, 2.66169111f, 2.52467219f },
+    { 6640.0f, 10.5042474f, 2.20872147f, 2.57026447f },
+    { 6660.0f, 6.41663126f, 1.79495067f, 2.61585674f },
+    { 6680.0f, 1.43481192f, 1.98199744f, 2.66144904f },
+    { 6700.0f, 4.70195633f, 3.56783383f, 2.70704129f },
+    { 6720.0f, 9.24916466f, 3.19126757f, 2.75263356f },
+    { 6740.0f, 12.0104865f, 2.72772658f, 2.79822584f },
+    { 6760.0f, 12.426478f, 2.24285516f, 2.84381811f },
+    { 6780.0f, 10.4437477f, 1.74764811f, 2.88941039f },
+    { 6800.0f, 6.49135418f, 1.24284104f, 2.93500266f },
+    { 6820.0f, 1.3836517f, 0.681566063f, 2.98059493f },
+    { 6840.0f, 3.8672852f, 3.41782182f, 3.0261872f },
+    { 6860.0f, 8.22345547f, 2.89374754f, 3.07177948f },
+    { 6875.625f, 10.4670119f, 2.48941288f, 3.10739852f },
+    { 6876.625f, 10.5682427f, 2.46371413f, 3.1096779f },
+    { 6877.625f, 10.6639564f, 2.43754392f, 3.1119578f },
+    { 6878.625f, 10.7544772f, 2.41192541f, 3.11423706f },
+    { 6879.625f, 10.8389994f, 2.38560569f, 3.11651711f },
+    { 6880.0f, 10.8696754f, 2.37634278f, 3.11737143f },
+    { 6880.625f, 10.9188077f, 2.360101f, 3.11879622f },
+    { 6881.625f, 10.9916893f, 2.33358954f, 3.12107645f },
+    { 6882.625f, 11.0610532f, 2.30820955f, 3.12335538f },
+    { 6883.625f, 11.121003f, 2.28146795f, 3.12563584f },
+    { 6884.625f, 11.1809523f, 2.2560483f, 3.12791472f },
+    { 6885.625f, 11.2238737f, 2.22927749f, 3.13019518f },
+    { 6886.625f, 11.278734f, 2.20213319f, 3.13247563f },
+    { 6887.625f, 11.2770393f, 2.17941084f, 3.13475148f },
+    { 6888.625f, 11.3582758f, 2.11571269f, 3.13706704f },
+    { 6889.625f, 11.380559f, 1.91578001f, 3.13660471f },
+    { 6890.625f, 11.4028423f, 1.71584733f, 3.13614238f },
+    { 6891.625f, 11.4251255f, 1.51591465f, 3.13568005f },
+    { 6892.625f, 11.4474088f, 1.31598197f, 3.13521772f },
+    { 6893.625f, 11.469692f, 1.11604929f, 3.13475539f },
+    { 6894.625f, 11.4429696f, 1.13717379f, 3.13248353f },
+    { 6895.625f, 11.4397235f, 1.17241146f, 3.13019426f },
+    { 6896.625f, 11.4252964f, 1.19591383f, 3.12791799f },
+    { 6897.625f, 11.4084703f, 1.22510826f, 3.12563518f },
+    { 6898.625f, 11.3858833f, 1.25010514f, 3.12335707f },
+    { 6899.625f, 11.3574934f, 1.27766693f, 3.12107607f },
+    { 6900.0f, 11.345647f, 1.28675084f, 3.1202221f },
+    { 6900.625f, 11.3242893f, 1.30335927f, 3.11879719f },
+    { 6901.625f, 11.2847704f, 1.33031562f, 3.11651691f },
+    { 6902.625f, 11.2406062f, 1.35637474f, 3.11423766f },
+    { 6903.625f, 11.1901593f, 1.38308491f, 3.11195771f },
+    { 6904.625f, 11.1349839f, 1.40937611f, 3.10967827f },
+    { 6905.625f, 11.0737499f, 1.43598111f, 3.1073985f },
+    { 6920.0f, 9.62856345f, 1.82143898f, 3.074629f },
+    { 6940.0f, 6.13457551f, 2.39214726f, 3.02903672f },
+    { 6960.0f, 1.73416484f, 3.29629043f, 2.98344445f },
+    { 6980.0f, 3.33891873f, 6.16553876f, 2.93785217f },
+    { 7000.0f, 7.24176088f, 0.5492689f, 2.8922599f },
+    { 7020.0f, 9.7226624f, 1.10773332f, 2.84666763f },
+    { 7040.0f, 10.337634f, 1.6485453f, 2.80107536f },
+    { 7060.0f, 9.04961343f, 2.18899632f, 2.75548308f },
+    { 7080.0f, 6.18678705f, 2.74652247f, 2.70989081f },
+    { 7100.0f, 2.38278724f, 3.42979515f, 2.66429853f },
+    { 7120.0f, 1.88684503f, 0.219151561f, 2.61870625f },
+    { 7140.0f, 5.39879423f, 0.953834798f, 2.57311398f },
+    { 7160.0f, 7.85478338f, 1.5051647f, 2.52752171f },
+    { 7180.0f, 8.84460664f, 2.02658476f, 2.48192943f },
+    { 7200.0f, 8.29156372f, 2.53023967f, 2.43633716f },
+    { 7220.0f, 6.40444096f, 3.00938517f, 2.39074488f },
+    { 7240.0f, 3.62545173f, 3.41897552f, 2.34515262f },
+    { 7260.0f, 3.17685153f, 2.58119541f, 2.29956034f },
+    { 7280.0f, 2.72825133f, 1.7434153f, 2.25396806f },
+    { 7300.0f, 5.00196476f, 2.08360575f, 2.20837579f },
+    { 7320.0f, 6.34548887f, 2.49804931f, 2.16278351f },
+    { 7340.0f, 6.64058845f, 2.90447286f, 2.11719124f },
+    { 7360.0f, 6.00773857f, 3.26841138f, 2.07159896f },
+    { 7380.0f, 4.77267788f, 3.53978596f, 2.02600669f },
+    { 7400.0f, 3.48007096f, 3.61728253f, 1.98041442f },
+    { 7420.0f, 2.91905032f, 3.42696306f, 1.93482214f },
+    { 7440.0f, 3.38750929f, 3.27766291f, 1.88922987f },
+    { 7460.0f, 4.17628441f, 3.3518263f, 1.8436376f },
+    { 7480.0f, 4.78365428f, 3.5355444f, 1.79804532f },
+    { 7500.0f, 5.09488438f, 3.75170269f, 1.75245304f },
+    { 7520.0f, 5.1314656f, 3.97043542f, 1.70686078f },
+    { 7540.0f, 4.92489335f, 4.17844615f, 1.6612685f },
+    { 7560.0f, 4.50051395f, 4.35724397f, 1.61567622f },
+    { 7580.0f, 3.95362122f, 4.46804971f, 1.57008395f },
+    { 7600.0f, 3.56321592f, 4.46705632f, 1.52449167f },
+    { 7620.0f, 3.70546528f, 4.41218459f, 1.4788994f },
+    { 7640.0f, 4.3593298f, 4.46478942f, 1.43330712f },
+    { 7660.0f, 5.05851391f, 4.66197292f, 1.38771485f },
+    { 7680.0f, 5.34735638f, 4.94756241f, 1.34212258f },
+    { 7700.0f, 4.96154f, 5.26151532f, 1.2965303f },
+    { 7720.0f, 3.87661586f, 5.52636361f, 1.25093803f },
+    { 7740.0f, 2.48268329f, 5.52412725f, 1.20534575f },
+    { 7760.0f, 2.33479387f, 4.96424558f, 1.15975348f },
+    { 7780.0f, 3.96546741f, 4.87122678f, 1.11416121f },
+    { 7800.0f, 5.65560427f, 5.16665903f, 1.06856893f },
+    { 7820.0f, 6.61148538f, 5.57960289f, 1.02297666f },
+    { 7840.0f, 6.47714952f, 6.03822485f, 0.977384381f },
+    { 7860.0f, 5.14967778f, 0.232955135f, 0.931792107f },
+    { 7880.0f, 2.76966557f, 0.704000785f, 0.886199829f },
+    { 7900.0f, 3.16616481f, 5.98528347f, 0.840607557f },
+    { 7920.0f, 3.56266404f, 4.98338084f, 0.795015284f },
+    { 7940.0f, 6.38156521f, 5.48417229f, 0.749423008f },
+    { 7960.0f, 8.21914951f, 6.00520307f, 0.703830737f },
+    { 7980.0f, 8.6665307f, 0.25355175f, 0.658238461f },
+    { 8000.0f, 7.55426384f, 0.798378055f, 0.612646186f },
+    { 8020.0f, 5.00541639f, 1.37825783f, 0.567053906f },
+    { 8040.0f, 1.51577274f, 2.257679f, 0.521461641f },
+    { 8060.0f, 2.80591073f, 5.17909216f, 0.47586936f },
+    { 8080.0f, 6.49237109f, 5.85777592f, 0.430277089f },
+    { 8100.0f, 9.19150863f, 0.139639248f, 0.384684815f },
+    { 8120.0f, 10.3101612f, 0.684215337f, 0.33909254f },
+    { 8140.0f, 9.56136216f, 1.22412357f, 0.293500267f },
+    { 8160.0f, 7.01159464f, 1.77100207f, 0.247907992f },
+    { 8180.0f, 3.0918167f, 2.38030478f, 0.202315715f },
+    { 8200.0f, 1.63135677f, 5.60022069f, 0.156723445f },
+    { 8220.0f, 6.01312586f, 0.0470317923f, 0.111131169f },
+    { 8240.0f, 9.38819928f, 0.589148069f, 0.0655389144f },
+    { 8253.75f, 10.7337299f, 0.947095553f, 0.0341940843f },
+    { 8254.75f, 10.7952205f, 0.972693767f, 0.0319146496f },
+    { 8255.75f, 10.8510499f, 0.998617445f, 0.0296348081f },
+    { 8256.75f, 10.9023529f, 1.0241377f, 0.0273553925f },
+    { 8257.75f, 10.9473901f, 1.05003785f, 0.0250755124f },
+    { 8258.75f, 10.9885458f, 1.07553664f, 0.0227960588f },
+    { 8259.75f, 11.0222291f, 1.1013758f, 0.0205161918f },
+    { 8260.0f, 11.0315394f, 1.1080634f, 0.0199459735f },
+    { 8260.75f, 11.0535794f, 1.12706915f, 0.0182364852f },
+    { 8261.75f, 11.0749897f, 1.15266997f, 0.0159568474f },
+    { 8262.75f, 11.0974527f, 1.17938993f, 0.0136760408f },
+    { 8263.75f, 11.1034145f, 1.20401509f, 0.0113975738f },
+    { 8264.75f, 11.1207899f, 1.23657205f, 0.00911080083f },
+    { 8265.75f, 11.092459f, 1.25492551f, 0.00684048983f },
+    { 8266.75f, 11.0824852f, 1.33577577f, 0.00684014038f },
+    { 8267.75f, 11.0725114f, 1.41662602f, 0.00683979093f },
+    { 8268.75f, 11.0625377f, 1.49747627f, 0.00683944148f },
+    { 8269.75f, 11.0525639f, 1.57832653f, 0.00683909203f },
+    { 8270.75f, 11.0425901f, 1.65917678f, 0.00683874259f },
+    { 8271.75f, 11.0326163f, 1.74002703f, 0.00683839314f },
+    { 8272.75f, 10.9927544f, 1.72274288f, 0.00910665994f },
+    { 8273.75f, 10.9490228f, 1.68632351f, 0.0113980677f },
+    { 8274.75f, 10.9044759f, 1.66388183f, 0.0136743266f },
+    { 8275.75f, 10.8512988f, 1.63571232f, 0.0159572045f },
+    { 8276.75f, 10.7959581f, 1.61167626f, 0.0182355927f },
+    { 8277.75f, 10.7327971f, 1.58554226f, 0.0205163956f },
+    { 8278.75f, 10.6664777f, 1.56096614f, 0.0227955342f },
+    { 8279.75f, 10.5931873f, 1.53557621f, 0.0250756265f },
+    { 8280.0f, 10.574932f, 1.52940004f, 0.0256454704f },
+    { 8280.75f, 10.5160238f, 1.51081728f, 0.0273550759f },
+    { 8281.75f, 10.4325251f, 1.48580968f, 0.0296348542f },
+    { 8282.75f, 10.3448136f, 1.46101089f, 0.0319144471f },
+    { 8283.75f, 10.25118f, 1.436208f, 0.0341940995f },
+    { 8300.0f, 8.05875603f, 1.04210149f, 0.0712379231f },
+    { 8320.0f, 3.94980632f, 0.618879654f, 0.116830211f },
+    { 8340.0f, 1.21558709f, 2.58866427f, 0.162422473f },
+    { 8360.0f, 5.89627356f, 2.51401361f, 0.208014751f },
+    { 8380.0f, 9.58075685f, 2.06874173f, 0.253607032f },
+    { 8400.0f, 11.3967424f, 1.60610613f, 0.2991993f },
+    { 8420.0f, 10.9448896f, 1.154356f, 0.344791574f },
+    { 8440.0f, 8.30577224f, 0.745754696f, 0.39038385f },
+    { 8460.0f, 4.16499989f, 0.541278428f, 0.435976123f },
+    { 8480.0f, 2.65833085f, 1.79554319f, 0.481568397f },
+    { 8500.0f, 7.02085522f, 1.92412347f, 0.527160672f },
+    { 8520.0f, 10.6644244f, 1.57270236f, 0.572752946f },
+    { 8540.0f, 12.2785033f, 1.16372022f, 0.618345221f },
+    { 8560.0f, 11.4214355f, 0.760779748f, 0.663937497f },
+    { 8580.0f, 8.26454083f, 0.428354725f, 0.70952977f },
+    { 8600.0f, 4.01397055f, 0.491505479f, 0.755122044f },
+    { 8620.0f, 4.73472468f, 1.53134368f, 0.800714327f },
+    { 8640.0f, 9.58582311f, 1.474398f, 0.846306592f },
+    { 8660.0f, 13.2874755f, 1.12600882f, 0.891898866f },
+    { 8680.0f, 14.4789527f, 0.723087599f, 0.937491141f },
+    { 8700.0f, 12.635482f, 0.322352214f, 0.983083415f },
+    { 8720.0f, 7.95955732f, 0.00464807813f, 1.02867569f },
+    { 8740.0f, 2.71608902f, 0.620246405f, 1.07426796f },
+    { 8760.0f, 8.07248562f, 1.54377145f, 1.11986024f },
+    { 8780.0f, 15.2519593f, 1.24217432f, 1.16545252f },
+    { 8800.0f, 20.3575329f, 0.825326003f, 1.21104479f },
+    { 8820.0f, 21.955811f, 0.381449466f, 1.25663706f },
+    { 8840.0f, 19.2801548f, 6.21708386f, 1.30222934f },
+    { 8860.0f, 12.3643904f, 5.79563007f, 1.34782161f },
+    { 8880.0f, 2.47163889f, 5.88673121f, 1.39341389f },
+    { 8900.0f, 10.3657893f, 1.42323028f, 1.43900616f },
+    { 8920.0f, 22.0828522f, 1.02569779f, 1.48459843f },
+    { 8940.0f, 31.1487265f, 0.567135747f, 1.53019071f },
+    { 8960.0f, 35.4357622f, 0.0954026658f, 1.57578298f },
+    { 8980.0f, 33.5123412f, 5.90424925f, 1.62137526f },
+    { 9000.0f, 24.969296f, 5.43757882f, 1.66696753f },
+    { 9020.0f, 10.6601429f, 5.03694841f, 1.71255981f },
+    { 9040.0f, 7.77846916f, 1.05109212f, 1.75815209f },
+    { 9060.0f, 26.5199672f, 0.706694861f, 1.80374435f },
+    { 9080.0f, 42.3722842f, 0.238740674f, 1.84933663f },
+    { 9100.0f, 51.5344979f, 6.03974989f, 1.8949289f },
+    { 9120.0f, 50.9612221f, 5.55609638f, 1.94052118f },
+    { 9140.0f, 39.0275904f, 5.08242869f, 1.98611345f },
+    { 9160.0f, 16.2836695f, 4.69098644f, 2.03170572f },
+    { 9180.0f, 14.9823667f, 0.685802938f, 2.077298f },
+    { 9200.0f, 47.3046927f, 0.32039446f, 2.12289027f },
+    { 9220.0f, 72.3324231f, 6.12958711f, 2.16848255f },
+    { 9240.0f, 77.6553919f, 5.64488366f, 2.21407482f },
+    { 9260.0f, 48.257811f, 5.18032958f, 2.2596671f },
+    { 9280.0f, 33.5909541f, 1.36235425f, 2.30525937f },
+    { 9300.0f, 185.996917f, 0.948868203f, 2.35085165f },
+    { 9320.0f, 429.380716f, 0.458102636f, 2.39644392f },
+    { 9340.0f, 783.457322f, 6.24256641f, 2.44203619f },
+    { 9360.0f, 1267.15022f, 5.74132985f, 2.48762847f },
+    { 9380.0f, 1897.50376f, 5.23902451f, 2.53322074f },
+    { 9400.0f, 2688.65791f, 4.73622293f, 2.57881302f },
+    { 9420.0f, 3650.81672f, 4.23320015f, 2.62440529f },
+    { 9440.0f, 4789.25107f, 3.73009941f, 2.66999757f },
+    { 9460.0f, 6103.4004f, 3.22699428f, 2.71558984f },
+    { 9480.0f, 7586.15841f, 2.7239195f, 2.76118211f },
+    { 9500.0f, 9223.43736f, 2.22088519f, 2.80677439f },
+    { 9520.0f, 10994.1097f, 1.71789058f, 2.85236666f },
+    { 9540.0f, 12870.4061f, 1.21492591f, 2.89795894f },
+    { 9560.0f, 14818.8096f, 0.711981735f, 2.94355121f },
+    { 9580.0f, 16801.4636f, 0.209047868f, 2.98914349f },
+    { 9600.0f, 18777.9631f, 5.98930263f, 3.03473576f },
+    { 9620.0f, 20707.6043f, 5.48637292f, 3.08032803f },
+    { 9631.875f, 21814.6301f, 5.1876154f, 3.10739858f },
+    { 9632.875f, 21906.764f, 5.16257277f, 3.10967807f },
+    { 9633.875f, 21997.3169f, 5.13727251f, 3.11195785f },
+    { 9634.875f, 22089.3464f, 5.11219491f, 3.11423737f },
+    { 9635.875f, 22178.6603f, 5.08690809f, 3.11651713f },
+    { 9636.875f, 22270.9186f, 5.06169638f, 3.11879679f },
+    { 9637.875f, 22358.3674f, 5.03650356f, 3.12107643f },
+    { 9638.875f, 22451.5798f, 5.01086264f, 3.12335652f },
+    { 9639.875f, 22535.6699f, 4.986013f, 3.12563573f },
+    { 9640.0f, 22547.3605f, 4.98173242f, 3.12592194f },
+    { 9640.875f, 22631.6987f, 4.95886623f, 3.12791739f },
+    { 9641.875f, 22707.739f, 4.93529067f, 3.13019496f },
+    { 9642.875f, 22813.0379f, 4.90083177f, 3.1324841f },
+    { 9643.875f, 22855.9026f, 4.88377715f, 3.13475272f },
+    { 9644.875f, 22948.5078f, 4.85083948f, 3.13475287f },
+    { 9645.875f, 23041.113f, 4.81790181f, 3.13475302f },
+    { 9646.875f, 23133.7183f, 4.78496413f, 3.13475316f },
+    { 9647.875f, 23226.3235f, 4.75202646f, 3.13475331f },
+    { 9648.875f, 23318.9287f, 4.71908879f, 3.13475346f },
+    { 9649.875f, 23411.534f, 4.68615112f, 3.13475361f },
+    { 9650.875f, 23512.4245f, 4.70285429f, 3.13248584f },
+    { 9651.875f, 23586.261f, 4.73905834f, 3.13019475f },
+    { 9652.875f, 23679.5309f, 4.76186483f, 3.1279181f },
+    { 9653.875f, 23758.8907f, 4.78979338f, 3.12563558f },
+    { 9654.875f, 23847.944f, 4.81419336f, 3.1233569f },
+    { 9655.875f, 23929.0959f, 4.84024798f, 3.12107634f },
+    { 9656.875f, 24015.6635f, 4.86517855f, 3.118797f },
+    { 9657.875f, 24097.3705f, 4.89062635f, 3.11651708f },
+    { 9658.875f, 24182.2169f, 4.91575789f, 3.1142375f },
+    { 9659.875f, 24263.9247f, 4.94097462f, 3.11195783f },
+    { 9660.0f, 24274.5519f, 4.944257f, 3.11167272f },
+    { 9660.875f, 24347.4275f, 4.96618308f, 3.10967815f },
+    { 9661.875f, 24428.8429f, 4.9913077f, 3.10739857f },
+    { 9680.0f, 25849.5102f, 5.44722129f, 3.06608046f },
+    { 9700.0f, 27254.0261f, 5.95017381f, 3.02048817f },
+    { 9720.0f, 28475.9725f, 0.16991922f, 2.9748959f },
+    { 9740.0f, 29511.4922f, 0.672849804f, 2.92930363f },
+    { 9760.0f, 30364.8824f, 1.17577541f, 2.88371135f },
+    { 9780.0f, 31047.5372f, 1.67870122f, 2.83811908f },
+    { 9800.0f, 31576.3601f, 2.18162887f, 2.7925268f },
+    { 9820.0f, 31971.9609f, 2.68456181f, 2.74693453f },
+    { 9840.0f, 32256.7391f, 3.1875028f, 2.70134225f },
+    { 9860.0f, 32453.1325f, 3.69045235f, 2.65574998f },
+    { 9880.0f, 32582.132f, 4.19340854f, 2.61015771f },
+    { 9900.0f, 32662.2085f, 4.69636837f, 2.56456543f },
+    { 9920.0f, 32708.6756f, 5.1993274f, 2.51897316f },
+    { 9940.0f, 32733.478f, 5.70228007f, 2.47338088f },
+    { 9960.0f, 32745.3456f, 6.20522281f, 2.42778861f },
+    { 9980.0f, 32750.2045f, 0.424968908f, 2.38219633f },
+    { 10000.0f, 32751.739f, 0.927890629f, 2.33660406f },
+    { 10020.0f, 32751.9931f, 1.43080692f, 2.29101179f },
+    { 10040.0f, 32751.9318f, 1.93372364f, 2.24541951f },
+    { 10060.0f, 32751.8938f, 2.43664727f, 2.19982724f },
+    { 10080.0f, 32751.9232f, 2.939583f, 2.15423496f },
+    { 10100.0f, 32751.9706f, 3.44253272f, 2.10864269f },
+    { 10120.0f, 32751.993f, 3.94549549f, 2.06305041f },
+    { 10140.0f, 32751.9832f, 4.44846703f, 2.01745814f },
+    { 10160.0f, 32751.959f, 4.95144019f, 1.97186587f },
+    { 10180.0f, 32751.9429f, 5.45440701f, 1.92627359f },
+    { 10200.0f, 32751.9462f, 5.95736078f, 1.88068132f },
+    { 10220.0f, 32751.9644f, 0.177111663f, 1.83508904f },
+    { 10240.0f, 32751.9846f, 0.680030058f, 1.78949677f },
+    { 10260.0f, 32751.9936f, 1.18293395f, 1.74390449f },
+    { 10280.0f, 32751.9875f, 1.68582982f, 1.69831222f },
+    { 10300.0f, 32751.971f, 2.18872628f, 1.65271994f },
+    { 10320.0f, 32751.9556f, 2.69163159f, 1.60712767f },
+    { 10340.0f, 32751.9514f, 3.19455199f, 1.5615354f },
+    { 10360.0f, 32751.961f, 3.6974908f, 1.51594312f },
+    { 10380.0f, 32751.9783f, 4.20044753f, 1.47035085f },
+    { 10400.0f, 32751.9918f, 4.70341789f, 1.42475857f },
+    { 10420.0f, 32751.992f, 5.20639598f, 1.3791663f },
+    { 10440.0f, 32751.9767f, 5.70937441f, 1.33357402f },
+    { 10460.0f, 32751.9557f, 6.21234662f, 1.28798175f },
+    { 10480.0f, 32751.9423f, 0.43212319f, 1.24238948f },
+    { 10500.0f, 32751.9473f, 0.935073268f, 1.1967972f },
+    { 10520.0f, 32751.969f, 1.43801204f, 1.15120493f },
+    { 10540.0f, 32751.9904f, 1.94094225f, 1.10561265f },
+    { 10560.0f, 32751.9881f, 2.4438679f, 1.06002038f },
+    { 10580.0f, 32751.9526f, 2.94679186f, 1.0144281f },
+    { 10600.0f, 32751.906f, 3.44971703f, 0.96883583f },
+    { 10620.0f, 32751.8997f, 3.95264339f, 0.923243555f },
+    { 10640.0f, 32751.9635f, 4.45557161f, 0.877651281f },
+    { 10660.0f, 32751.964f, 4.95850002f, 0.832059007f },
+    { 10680.0f, 32751.3556f, 5.46142819f, 0.786466732f },
+    { 10700.0f, 32748.7964f, 5.96435663f, 0.740874458f },
+    { 10720.0f, 32741.6476f, 0.184101279f, 0.695282184f },
+    { 10740.0f, 32725.3868f, 0.687035411f, 0.649689909f },
+    { 10760.0f, 32693.0109f, 1.18997618f, 0.604097635f },
+    { 10780.0f, 32634.5215f, 1.69292561f, 0.558505361f },
+    { 10800.0f, 32536.6037f, 2.19588415f, 0.512913086f },
+    { 10820.0f, 32382.6155f, 2.69884981f, 0.467320812f },
+    { 10840.0f, 32152.9577f, 3.20181841f, 0.421728538f },
+    { 10860.0f, 31825.8995f, 3.70478517f, 0.376136263f },
+    { 10880.0f, 31378.8188f, 4.20774308f, 0.330543989f },
+    { 10900.0f, 30789.8217f, 4.71068767f, 0.284951715f },
+    { 10920.0f, 30039.5705f, 5.21361595f, 0.23935944f },
+    { 10940.0f, 29113.1961f, 5.71652668f, 0.193767167f },
+    { 10960.0f, 28002.0161f, 6.21942665f, 0.148174892f },
+    { 10980.0f, 26704.9467f, 0.43912893f, 0.102582624f },
+    { 11000.0f, 25229.3536f, 0.942060183f, 0.0569903147f },
+    { 11010.0f, 24428.8194f, 1.1936217f, 0.0341940765f },
+    { 11011.0f, 24347.3311f, 1.21870244f, 0.0319145437f },
+    { 11012.0f, 24263.8543f, 1.2439576f, 0.0296348139f },
+    { 11013.0f, 24182.0947f, 1.2691036f, 0.0273552151f },
+    { 11014.0f, 24097.1973f, 1.29431255f, 0.0250755438f },
+    { 11015.0f, 24015.5081f, 1.31964458f, 0.0227957523f },
+    { 11016.0f, 23928.682f, 1.3447037f, 0.020516266f },
+    { 11017.0f, 23847.7431f, 1.37056357f, 0.0182359241f },
+    { 11018.0f, 23757.8308f, 1.39517755f, 0.0159569901f },
+    { 11019.0f, 23679.2618f, 1.4227605f, 0.0136748555f },
+    { 11020.0f, 23582.9524f, 1.44591276f, 0.0113977902f },
+    { 11021.0f, 23512.0273f, 1.48144255f, 0.00910747536f },
+    { 11022.0f, 23394.5927f, 1.49816089f, 0.00683950183f },
+    { 11023.0f, 23380.0256f, 1.63346224f, 0.00444928565f },
+    { 11024.0f, 23238.3357f, 1.90075794f, 0.00213215078f },
+    { 11025.0f, 46318.3101f, 1.57079627f, 5.36295678e-11f },
+};
+
+static const TPqfWidebandPoint* const PqfWidebandTables[PqfWidebandSubbands] = {
+    PqfWidebandTable0,
+    PqfWidebandTable1,
+    PqfWidebandTable2,
+    PqfWidebandTable3,
+    PqfWidebandTable4,
+    PqfWidebandTable5,
+    PqfWidebandTable6,
+    PqfWidebandTable7,
+};
+
+} // namespace NAtracDEnc
diff --git a/src/atrac/at3p/tools/pqf_wideband_calibrate.cpp b/src/atrac/at3p/tools/pqf_wideband_calibrate.cpp
new file mode 100644
index 0000000..88281b8
--- /dev/null
+++ b/src/atrac/at3p/tools/pqf_wideband_calibrate.cpp
@@ -0,0 +1,427 @@
+/*
+ * This file is part of AtracDEnc.
+ *
+ * AtracDEnc is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * AtracDEnc is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with AtracDEnc; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*
+ * One-off offline generator for src/atrac/at3p/at3p_pqf_wideband_table.h.
+ *
+ * Phase 1 experiment tool (see plan: "wideband GHA + analytic PQF-domain
+ * projection"). Unlike pqf_boundary_calibrate.cpp (which only measured the
+ * two subbands immediately flanking each of the 7 GHA subband boundaries,
+ * over a narrow +-40Hz window), this probes the REAL production PQF filter
+ * (at3plus_pqf_do_analyse) with synthetic sinusoids swept across the FULL
+ * 0-11025Hz range covered by GHA's 8 subbands, and measures the complex gain
+ * in ALL 8 subbands at every probe frequency. This directly answers, from
+ * measurement rather than assumption:
+ *   - how far a tone's energy leaks beyond its immediate neighbor subband
+ *     (the "aliasing" question -- does subband k+2, k+3... ever pick up
+ *     non-negligible energy from a tone nominally in subband k?)
+ *   - the sign/parity ("spectral inversion") pattern of each subband's local
+ *     frequency axis, empirically, subband by subband
+ *   - the same omega=0/pi model singularity found in the boundary-only tool
+ *     recurs at EVERY subband's own edges (not just the 7 shared
+ *     boundaries) -- repaired the same way, generically, wherever it's
+ *     detected (not hardcoded to known boundary positions).
+ *
+ * Frequency/magnitude/phase are measured via Goertzel correlation +
+ * golden-section search (NOT libgha's gha_search_omega_newton, which is
+ * structurally ill-conditioned near omega=0/pi).
+ *
+ * Not part of the CMake build. To regenerate (run from repo root):
+ *
+ *   g++ -O2 -std=c++17 -I src -Dkiss_fft_scalar=float \
+ *       src/atrac/at3p/tools/pqf_wideband_calibrate.cpp \
+ *       src/atrac/atrac3plus_pqf/atrac3plus_pqf.c \
+ *       src/lib/mdct/mdct.cpp \
+ *       src/lib/fft/kissfft_impl/kiss_fft.c \
+ *       -o /tmp/pqf_wideband_calibrate
+ *   /tmp/pqf_wideband_calibrate > src/atrac/at3p/at3p_pqf_wideband_table.h
+ *
+ * Watch stderr: it prints a leakage-vs-distance summary (max magnitude
+ * ratio, in dB relative to the home subband, seen at |sb - home| = 1, 2,
+ * 3...) -- this is the data the "how many neighbor subbands do we need to
+ * model" decision should be based on.
+ */
+
+#include <atrac/atrac3plus_pqf/atrac3plus_pqf.h>
+
+#include <algorithm>
+#include <cmath>
+#include <complex>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <vector>
+
+namespace {
+
+constexpr double kFs = 44100.0;
+constexpr int kFrameSz = 2048;
+constexpr int kSubbandSz = 128;
+constexpr int kWarmupFrames = 4;
+constexpr int kMeasureFrames = 16;
+constexpr int kMeasureSamples = kMeasureFrames * kSubbandSz; // 2048
+constexpr int kGhaSubbands = 8; // matches TGhaProcessor::SUBBANDS
+constexpr double kSubbandBw = kFs / 32.0; // 1378.125 Hz
+constexpr double kFreqMax = kGhaSubbands * kSubbandBw; // 11025 Hz
+
+using Complex = std::complex<double>;
+
+// Same proven methodology as pqf_boundary_calibrate.cpp -- see that file for
+// the derivation of the magnitude/phase recovery formula.
+Complex Goertzel(const float* x, int n, double omega) {
+    Complex acc(0.0, 0.0);
+    const double norm = 2.0 * M_PI / (n - 1);
+    for (int i = 0; i < n; i++) {
+        double w = 0.5 * (1.0 - std::cos(norm * i));
+        Complex e(std::cos(omega * i), -std::sin(omega * i));
+        acc += w * (double)x[i] * e;
+    }
+    return acc;
+}
+
+double Mag2(const float* x, int n, double omega) {
+    Complex c = Goertzel(x, n, omega);
+    return c.real() * c.real() + c.imag() * c.imag();
+}
+
+double GoldenSectionMaxOmega(const float* x, int n, double a, double b, int iters = 40) {
+    const double gr = (std::sqrt(5.0) - 1.0) / 2.0;
+    double c = b - gr * (b - a);
+    double d = a + gr * (b - a);
+    for (int i = 0; i < iters; i++) {
+        if (Mag2(x, n, c) < Mag2(x, n, d)) {
+            a = c;
+        } else {
+            b = d;
+        }
+        c = b - gr * (b - a);
+        d = a + gr * (b - a);
+    }
+    return (a + b) / 2.0;
+}
+
+double CoarseSearchOmega(const float* x, int n) {
+    const int kSteps = 256;
+    double best = 0.0;
+    double bestMag2 = -1.0;
+    for (int i = 1; i < kSteps; i++) {
+        double omega = M_PI * i / kSteps;
+        double m2 = Mag2(x, n, omega);
+        if (m2 > bestMag2) {
+            bestMag2 = m2;
+            best = omega;
+        }
+    }
+    double lo = std::max(0.0, best - M_PI / kSteps);
+    double hi = std::min(M_PI, best + M_PI / kSteps);
+    return GoldenSectionMaxOmega(x, n, lo, hi);
+}
+
+struct TMeasured {
+    double Omega;
+    double Magnitude;
+    double Phase; // x[n] ~= Magnitude * sin(Omega*n + Phase)
+};
+
+TMeasured Recover(const float* x, int n, double omega) {
+    Complex X = Goertzel(x, n, omega);
+    double mag = 4.0 * std::abs(X) / n;
+    double phase = std::arg(X) + M_PI / 2.0;
+    while (phase < 0) phase += 2 * M_PI;
+    while (phase >= 2 * M_PI) phase -= 2 * M_PI;
+    return {omega, mag, phase};
+}
+
+double ResidualCheck(const float* x, int n, const TMeasured& m) {
+    double num = 0.0;
+    for (int i = 0; i < n; i++) {
+        double pred = m.Magnitude * std::sin(m.Omega * i + m.Phase);
+        double diff = x[i] - pred;
+        num += diff * diff;
+    }
+    return std::sqrt(num / n);
+}
+
+// Probe the real PQF with a continuous-phase unit-amplitude sine at
+// `freqHz`, and return the last kMeasureSamples subband-domain samples for
+// ALL 8 GHA subbands (one probe covers every subband at once -- the PQF
+// call itself always computes all 16 subbands regardless of how many we
+// read).
+void ProbeAllSubbands(double freqHz, std::vector<std::vector<float>>* subbands) {
+    at3plus_pqf_a_ctx_t ctx = at3plus_pqf_create_a_ctx();
+
+    subbands->assign(kGhaSubbands, std::vector<float>(kMeasureSamples, 0.0f));
+
+    std::vector<float> in(kFrameSz);
+    std::vector<float> out(kFrameSz);
+
+    const int totalFrames = kWarmupFrames + kMeasureFrames;
+    const double omegaOrig = 2.0 * M_PI * freqHz / kFs;
+
+    int measuredFrames = 0;
+    // Zero-reference the probe's phase at the START OF THE MEASUREMENT
+    // WINDOW (n0 = kWarmupFrames*kFrameSz), not at the probe's own n=0.
+    // Recover() below fits the subband output as Mag*sin(Omega*i+Phase)
+    // with i local to the measurement window (i=0 at n0); for that Phase to
+    // be purely the filter's own phase response theta_sb(f) -- so that a
+    // caller can later do predicted_phase = tone_phase + table_phase,
+    // referencing both consistently to their own window starts -- the
+    // INPUT must already have zero phase at n0. Without this, Phase would
+    // be contaminated by (omegaOrig*n0 mod 2pi), which is an artifact of
+    // this calibration run's arbitrary warmup length, not a filter
+    // property, and silently breaks the additive phase-composition formula
+    // used downstream (confirmed by a direct reconstruction test: skipping
+    // this shift gave ~-5dB SNR reconstructing a plain mid-passband tone
+    // that should be a near-perfect, trivial case).
+    const long n0 = (long)kWarmupFrames * kFrameSz;
+    for (int f = 0; f < totalFrames; f++) {
+        for (int i = 0; i < kFrameSz; i++) {
+            long n = (long)f * kFrameSz + i - n0;
+            in[i] = (float)std::sin(omegaOrig * n);
+        }
+        at3plus_pqf_do_analyse(ctx, in.data(), out.data());
+
+        if (f >= kWarmupFrames) {
+            for (int sb = 0; sb < kGhaSubbands; sb++) {
+                memcpy((*subbands)[sb].data() + measuredFrames * kSubbandSz,
+                       out.data() + sb * kSubbandSz, sizeof(float) * kSubbandSz);
+            }
+            measuredFrames++;
+        }
+    }
+
+    at3plus_pqf_free_a_ctx(ctx);
+}
+
+struct TWidebandPoint {
+    double FreqHz;
+    TMeasured Sb[kGhaSubbands];
+    double Residual[kGhaSubbands] = {0};
+};
+
+// Build the non-uniform probe grid: fine step near each of the 7 known
+// subband boundaries and the two outer edges (0Hz, 11025Hz), coarse step
+// elsewhere. The repair pass below does not rely on this grid knowing where
+// boundaries are (it detects badness generically), but a fine step is still
+// needed there to have enough repair-neighbor points close to the
+// singularity, and a fine step at the outer edges checks whether subband0's
+// DC edge and subband7's 11025Hz edge show the same singularity.
+std::vector<double> BuildFrequencyGrid() {
+    std::vector<double> special;
+    for (int b = 0; b <= kGhaSubbands; b++) {
+        special.push_back(b * kSubbandBw); // 0, 1378.125, ..., 11025
+    }
+
+    std::vector<double> grid;
+    const double kFineStep = 1.0;
+    const double kFineHalfWidth = 15.0;
+    const double kCoarseStep = 20.0;
+
+    for (double f = 0.0; f <= kFreqMax + 1e-6; f += kCoarseStep) {
+        grid.push_back(f);
+    }
+    for (double c : special) {
+        for (double f = std::max(0.0, c - kFineHalfWidth); f <= std::min(kFreqMax, c + kFineHalfWidth) + 1e-6;
+             f += kFineStep) {
+            grid.push_back(f);
+        }
+    }
+    // A probe frequency of exactly 0Hz is degenerate (not a sine at all);
+    // nudge it up slightly.
+    for (double& f : grid) {
+        if (f < 1.0) f = 1.0;
+    }
+
+    std::sort(grid.begin(), grid.end());
+    grid.erase(std::unique(grid.begin(), grid.end(), [](double a, double b) { return std::abs(a - b) < 1e-6; }),
+               grid.end());
+    return grid;
+}
+
+std::vector<TWidebandPoint> SweepFullBand() {
+    std::vector<double> grid = BuildFrequencyGrid();
+    std::vector<TWidebandPoint> points;
+    points.reserve(grid.size());
+
+    for (size_t gi = 0; gi < grid.size(); gi++) {
+        double freqHz = grid[gi];
+        std::vector<std::vector<float>> subbands;
+        ProbeAllSubbands(freqHz, &subbands);
+
+        TWidebandPoint p;
+        p.FreqHz = freqHz;
+        for (int sb = 0; sb < kGhaSubbands; sb++) {
+            double omega = CoarseSearchOmega(subbands[sb].data(), kMeasureSamples);
+            TMeasured m = Recover(subbands[sb].data(), kMeasureSamples, omega);
+            p.Sb[sb] = m;
+            p.Residual[sb] = ResidualCheck(subbands[sb].data(), kMeasureSamples, m);
+        }
+        points.push_back(p);
+
+        if (gi % 100 == 0) {
+            std::fprintf(stderr, "swept %zu/%zu (freq=%.1f Hz)\n", gi, grid.size(), freqHz);
+        }
+    }
+    return points;
+}
+
+// Generic repair, same principle as pqf_boundary_calibrate.cpp's
+// RepairSingularity: detect bad points (magnitude below floor, or residual
+// too large relative to magnitude -- the omega=0/pi model singularity) and
+// linearly interpolate from the nearest good neighbors, per subband,
+// wherever it occurs across the whole sweep (not just at known boundaries).
+void RepairSingularities(std::vector<TWidebandPoint>* points) {
+    const double kRelBad = 0.02;
+    const double kMagFloor = 1.0;
+
+    auto isBad = [&](size_t i, int sb) {
+        double mag = (*points)[i].Sb[sb].Magnitude;
+        double res = (*points)[i].Residual[sb];
+        return mag < kMagFloor || (res / std::max(mag, kMagFloor)) > kRelBad;
+    };
+
+    auto unwrapLerp = [](double phaseA, double phaseB, double t) {
+        double d = std::fmod(phaseB - phaseA + M_PI, 2 * M_PI);
+        if (d < 0) d += 2 * M_PI;
+        d -= M_PI;
+        double r = phaseA + d * t;
+        while (r < 0) r += 2 * M_PI;
+        while (r >= 2 * M_PI) r -= 2 * M_PI;
+        return r;
+    };
+
+    for (int sb = 0; sb < kGhaSubbands; sb++) {
+        size_t n = points->size();
+        size_t i = 0;
+        int repairedRuns = 0;
+        while (i < n) {
+            if (!isBad(i, sb)) { i++; continue; }
+            size_t j = i;
+            while (j < n && isBad(j, sb)) j++;
+            if (i == 0 || j == n) {
+                std::fprintf(stderr, "warning: sb=%d bad run [%zu,%zu) touches sweep edge, cannot repair\n", sb, i, j);
+                i = j;
+                continue;
+            }
+            const TMeasured& a = (*points)[i - 1].Sb[sb];
+            const TMeasured& b = (*points)[j].Sb[sb];
+            double freqA = (*points)[i - 1].FreqHz;
+            double freqB = (*points)[j].FreqHz;
+            for (size_t k = i; k < j; k++) {
+                double t = (points->at(k).FreqHz - freqA) / (freqB - freqA);
+                TMeasured m;
+                m.Magnitude = a.Magnitude + (b.Magnitude - a.Magnitude) * t;
+                m.Omega = a.Omega + (b.Omega - a.Omega) * t;
+                m.Phase = unwrapLerp(a.Phase, b.Phase, t);
+                (*points)[k].Sb[sb] = m;
+            }
+            repairedRuns++;
+            i = j;
+        }
+        if (repairedRuns > 0) {
+            std::fprintf(stderr, "sb=%d: repaired %d singularity run(s)\n", sb, repairedRuns);
+        }
+    }
+}
+
+// The core "aliasing" diagnostic: for each probe point, find the home
+// subband (max magnitude), then for every OTHER subband record its
+// magnitude ratio (dB) relative to home, bucketed by |sb - home|. Prints the
+// worst-case (max) ratio per distance across the whole sweep -- this is the
+// data the neighbor-count decision should be based on.
+void PrintLeakageDiagnostic(const std::vector<TWidebandPoint>& points) {
+    double worstDb[kGhaSubbands] = {0};
+    for (double& v : worstDb) v = -1e300;
+
+    for (const auto& p : points) {
+        int home = 0;
+        for (int sb = 1; sb < kGhaSubbands; sb++) {
+            if (p.Sb[sb].Magnitude > p.Sb[home].Magnitude) home = sb;
+        }
+        double homeMag = std::max(p.Sb[home].Magnitude, 1.0);
+        for (int sb = 0; sb < kGhaSubbands; sb++) {
+            int dist = std::abs(sb - home);
+            if (dist == 0) continue;
+            double ratio = p.Sb[sb].Magnitude / homeMag;
+            double db = 20.0 * std::log10(std::max(ratio, 1e-9));
+            worstDb[dist] = std::max(worstDb[dist], db);
+        }
+    }
+
+    std::fprintf(stderr, "\n=== leakage-vs-distance diagnostic ===\n");
+    for (int dist = 1; dist < kGhaSubbands; dist++) {
+        if (worstDb[dist] < -200) continue; // never observed at this distance
+        std::fprintf(stderr, "  |sb - home| = %d : worst-case leakage = %.1f dB\n", dist, worstDb[dist]);
+    }
+    std::fprintf(stderr, "=======================================\n\n");
+}
+
+std::string FormatFloatLiteral(double v) {
+    char buf[64];
+    std::snprintf(buf, sizeof(buf), "%.9g", v);
+    std::string s(buf);
+    if (s.find_first_of(".eE") == std::string::npos) {
+        s += ".0";
+    }
+    s += "f";
+    return s;
+}
+
+void EmitTable(FILE* out, const std::vector<TWidebandPoint>& points) {
+    std::fprintf(out, "/* GENERATED FILE. See src/atrac/at3p/tools/pqf_wideband_calibrate.cpp */\n");
+    std::fprintf(out, "#pragma once\n\n");
+    std::fprintf(out, "#include <cstddef>\n\n");
+    std::fprintf(out, "namespace NAtracDEnc {\n\n");
+    std::fprintf(out, "struct TPqfWidebandPoint {\n");
+    std::fprintf(out, "    float FreqHz;\n");
+    std::fprintf(out, "    float Magnitude, Phase, Omega;\n");
+    std::fprintf(out, "};\n\n");
+    std::fprintf(out, "constexpr size_t PqfWidebandTableSize = %zu;\n", points.size());
+    std::fprintf(out, "constexpr size_t PqfWidebandSubbands = %d;\n\n", kGhaSubbands);
+
+    for (int sb = 0; sb < kGhaSubbands; sb++) {
+        std::fprintf(out, "static const TPqfWidebandPoint PqfWidebandTable%d[] = {\n", sb);
+        for (const auto& p : points) {
+            std::fprintf(out, "    { %s, %s, %s, %s },\n", FormatFloatLiteral(p.FreqHz).c_str(),
+                         FormatFloatLiteral(p.Sb[sb].Magnitude).c_str(), FormatFloatLiteral(p.Sb[sb].Phase).c_str(),
+                         FormatFloatLiteral(p.Sb[sb].Omega).c_str());
+        }
+        std::fprintf(out, "};\n\n");
+    }
+
+    std::fprintf(out, "static const TPqfWidebandPoint* const PqfWidebandTables[PqfWidebandSubbands] = {\n");
+    for (int sb = 0; sb < kGhaSubbands; sb++) {
+        std::fprintf(out, "    PqfWidebandTable%d,\n", sb);
+    }
+    std::fprintf(out, "};\n\n");
+    std::fprintf(out, "} // namespace NAtracDEnc\n");
+}
+
+} // namespace
+
+int main() {
+    std::fprintf(stderr, "sweeping full band 0-%.1f Hz across %d subbands...\n", kFreqMax, kGhaSubbands);
+    std::vector<TWidebandPoint> points = SweepFullBand();
+    std::fprintf(stderr, "swept %zu points total\n", points.size());
+
+    PrintLeakageDiagnostic(points);
+    RepairSingularities(&points);
+
+    EmitTable(stdout, points);
+    return 0;
+}
diff --git a/src/atrac3p.h b/src/atrac3p.h
index 779929d..99c17c2 100644
--- a/src/atrac3p.h
+++ b/src/atrac3p.h
@@ -31,13 +31,29 @@ public:
             GHA_PASS_INPUT =     1,
             GHA_WRITE_TONAL =    1 << 1,
             GHA_WRITE_RESIUDAL = 1 << 2,
+            // Opt-in: extract tones from the wideband (pre-PQF) signal and
+            // analytically project them into the PQF subband domain,
+            // instead of detecting them independently per subband. Fixes
+            // amplitude dropouts for tones near PQF subband boundaries; see
+            // the "wideband GHA + PQF-domain projection" experiment. Off by
+            // default: v1 has no onset/offset (envelope) detection of its
+            // own (always-present tones) and is unproven on real content.
+            GHA_WIDEBAND =       1 << 3,
 
             GHA_ENABLED = GHA_PASS_INPUT | GHA_WRITE_TONAL | GHA_WRITE_RESIUDAL
         };
         uint8_t UseGha;
 
+        // Wideband (GHA_WIDEBAND) tone-refinement strategy, selected via the
+        // "ghawbrefine" advanced option. 0 = subband-domain Newton refit
+        // (default, proven to beat legacy on real audio); 1 = raw-2048-domain
+        // joint refit then re-project (experimental). No effect unless
+        // GHA_WIDEBAND is set.
+        uint8_t WidebandRefineMode;
+
         TSettings()
             : UseGha(GHA_ENABLED)
+            , WidebandRefineMode(0)
         {}
     };
     TAt3PEnc(TCompressedOutputPtr&& out, int channels, TSettings settings);