// Case 27: clustered_down_events; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case27()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = (I % 29 < 4 ? -0.002 : 0.00015);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "clustered_down_events: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "clustered_down_events: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "clustered_down_events: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "clustered_down_events: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "clustered_down_events: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "clustered_down_events: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[206] = 2.;
    TS2Expect(TS2Evaluate() == 0., "clustered_down_events: implausible return rejected");
    TS2Expect(TS2Quality == 0., "clustered_down_events: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "clustered_down_events: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "clustered_down_events: quality restored");
}
// Case 28: capped_sawtooth; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case28()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.00012 * ((I % 19) - 9);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "capped_sawtooth: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "capped_sawtooth: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "capped_sawtooth: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "capped_sawtooth: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "capped_sawtooth: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "capped_sawtooth: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[243] = 2.;
    TS2Expect(TS2Evaluate() == 0., "capped_sawtooth: implausible return rejected");
    TS2Expect(TS2Quality == 0., "capped_sawtooth: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "capped_sawtooth: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "capped_sawtooth: quality restored");
}
// Case 29: triangular_wave; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case29()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.00015 * (abs((I % 24) - 12) - 6);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "triangular_wave: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "triangular_wave: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "triangular_wave: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "triangular_wave: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "triangular_wave: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "triangular_wave: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[24] = 2.;
    TS2Expect(TS2Evaluate() == 0., "triangular_wave: implausible return rejected");
    TS2Expect(TS2Quality == 0., "triangular_wave: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "triangular_wave: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "triangular_wave: quality restored");
}
// Case 30: convex_drift; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case30()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0001 + 0.001 * pow(I / 256., 2.);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "convex_drift: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "convex_drift: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "convex_drift: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "convex_drift: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "convex_drift: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "convex_drift: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[61] = 2.;
    TS2Expect(TS2Evaluate() == 0., "convex_drift: implausible return rejected");
    TS2Expect(TS2Quality == 0., "convex_drift: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "convex_drift: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "convex_drift: quality restored");
}
// Case 31: concave_drift; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case31()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0011 - 0.001 * pow(I / 256., 2.);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "concave_drift: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "concave_drift: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "concave_drift: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "concave_drift: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "concave_drift: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "concave_drift: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[98] = 2.;
    TS2Expect(TS2Evaluate() == 0., "concave_drift: implausible return rejected");
    TS2Expect(TS2Quality == 0., "concave_drift: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "concave_drift: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "concave_drift: quality restored");
}
// Case 32: sigmoid_transition; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case32()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.001 * (2. / (1. + exp((I - 90.) / 12.)) - 1.);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "sigmoid_transition: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "sigmoid_transition: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "sigmoid_transition: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "sigmoid_transition: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "sigmoid_transition: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "sigmoid_transition: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[135] = 2.;
    TS2Expect(TS2Evaluate() == 0., "sigmoid_transition: implausible return rejected");
    TS2Expect(TS2Quality == 0., "sigmoid_transition: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "sigmoid_transition: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "sigmoid_transition: quality restored");
}
// Case 33: damped_oscillation; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case33()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.002 * exp(-0.012 * I) * cos(0.37 * I);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "damped_oscillation: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "damped_oscillation: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "damped_oscillation: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "damped_oscillation: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "damped_oscillation: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "damped_oscillation: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[172] = 2.;
    TS2Expect(TS2Evaluate() == 0., "damped_oscillation: implausible return rejected");
    TS2Expect(TS2Quality == 0., "damped_oscillation: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "damped_oscillation: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "damped_oscillation: quality restored");
}
// Case 34: growing_oscillation; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case34()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0001 * exp(0.008 * I) * cos(0.37 * I);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "growing_oscillation: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "growing_oscillation: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "growing_oscillation: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "growing_oscillation: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "growing_oscillation: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "growing_oscillation: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[209] = 2.;
    TS2Expect(TS2Evaluate() == 0., "growing_oscillation: implausible return rejected");
    TS2Expect(TS2Quality == 0., "growing_oscillation: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "growing_oscillation: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "growing_oscillation: quality restored");
}
// Case 35: phase_discontinuity; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case35()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.001 * sin(0.3 * I + (I < 40 ? 1.5 : 0.));
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "phase_discontinuity: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "phase_discontinuity: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "phase_discontinuity: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "phase_discontinuity: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "phase_discontinuity: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "phase_discontinuity: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[246] = 2.;
    TS2Expect(TS2Evaluate() == 0., "phase_discontinuity: implausible return rejected");
    TS2Expect(TS2Quality == 0., "phase_discontinuity: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "phase_discontinuity: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "phase_discontinuity: quality restored");
}
// Case 36: frequency_discontinuity; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case36()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.001 * sin((I < 80 ? 0.17 : 0.63) * I);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "frequency_discontinuity: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "frequency_discontinuity: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "frequency_discontinuity: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "frequency_discontinuity: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "frequency_discontinuity: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "frequency_discontinuity: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[27] = 2.;
    TS2Expect(TS2Evaluate() == 0., "frequency_discontinuity: implausible return rejected");
    TS2Expect(TS2Quality == 0., "frequency_discontinuity: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "frequency_discontinuity: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "frequency_discontinuity: quality restored");
}
// Case 37: amplitude_discontinuity; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case37()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = (I < 80 ? 0.002 : 0.0003) * sin(0.4 * I);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "amplitude_discontinuity: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "amplitude_discontinuity: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "amplitude_discontinuity: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "amplitude_discontinuity: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "amplitude_discontinuity: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "amplitude_discontinuity: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[64] = 2.;
    TS2Expect(TS2Evaluate() == 0., "amplitude_discontinuity: implausible return rejected");
    TS2Expect(TS2Quality == 0., "amplitude_discontinuity: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "amplitude_discontinuity: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "amplitude_discontinuity: quality restored");
}
// Case 38: smooth_pulse; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case38()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.003 * exp(-pow((I - 32.) / 12., 2.)) - 0.0003;
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "smooth_pulse: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "smooth_pulse: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "smooth_pulse: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "smooth_pulse: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "smooth_pulse: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "smooth_pulse: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[101] = 2.;
    TS2Expect(TS2Evaluate() == 0., "smooth_pulse: implausible return rejected");
    TS2Expect(TS2Quality == 0., "smooth_pulse: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "smooth_pulse: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "smooth_pulse: quality restored");
}
// Case 39: double_pulse; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case39()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.002 * exp(-pow((I - 16.) / 6., 2.)) - 0.002 * exp(-pow((I - 60.) / 9., 2.));
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "double_pulse: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "double_pulse: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "double_pulse: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "double_pulse: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "double_pulse: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "double_pulse: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[138] = 2.;
    TS2Expect(TS2Evaluate() == 0., "double_pulse: implausible return rejected");
    TS2Expect(TS2Quality == 0., "double_pulse: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "double_pulse: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "double_pulse: quality restored");
}
// Case 40: cross_scale_conflict; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case40()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0008 * cos(0.04 * I) - 0.001 * cos(0.6 * I);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "cross_scale_conflict: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "cross_scale_conflict: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "cross_scale_conflict: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "cross_scale_conflict: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "cross_scale_conflict: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "cross_scale_conflict: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[175] = 2.;
    TS2Expect(TS2Evaluate() == 0., "cross_scale_conflict: implausible return rejected");
    TS2Expect(TS2Quality == 0., "cross_scale_conflict: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "cross_scale_conflict: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "cross_scale_conflict: quality restored");
}
// Case 41: near_flat_noise; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case41()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0000002 * sin(0.73 * I) + 0.0000001 * cos(0.29 * I);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "near_flat_noise: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "near_flat_noise: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "near_flat_noise: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "near_flat_noise: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "near_flat_noise: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "near_flat_noise: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[212] = 2.;
    TS2Expect(TS2Evaluate() == 0., "near_flat_noise: implausible return rejected");
    TS2Expect(TS2Quality == 0., "near_flat_noise: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "near_flat_noise: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "near_flat_noise: quality restored");
}
// Case 42: large_return_units; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case42()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.03 * sin(0.13 * I) + 0.01 * cos(0.7 * I);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "large_return_units: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "large_return_units: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "large_return_units: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "large_return_units: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "large_return_units: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "large_return_units: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[249] = 2.;
    TS2Expect(TS2Evaluate() == 0., "large_return_units: implausible return rejected");
    TS2Expect(TS2Quality == 0., "large_return_units: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "large_return_units: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "large_return_units: quality restored");
}
// Case 43: deterministic_roughness; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case43()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.001 * sin(12.9898 * I + 78.233 * sin(4.1414 * I));
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "deterministic_roughness: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "deterministic_roughness: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "deterministic_roughness: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "deterministic_roughness: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "deterministic_roughness: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "deterministic_roughness: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[30] = 2.;
    TS2Expect(TS2Evaluate() == 0., "deterministic_roughness: implausible return rejected");
    TS2Expect(TS2Quality == 0., "deterministic_roughness: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "deterministic_roughness: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "deterministic_roughness: quality restored");
}
// Case 44: weeklike_gaps; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case44()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = (I % 120 < 8 ? 0. : 0.001 * cos(0.33 * I));
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "weeklike_gaps: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "weeklike_gaps: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "weeklike_gaps: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "weeklike_gaps: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "weeklike_gaps: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "weeklike_gaps: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[67] = 2.;
    TS2Expect(TS2Evaluate() == 0., "weeklike_gaps: implausible return rejected");
    TS2Expect(TS2Quality == 0., "weeklike_gaps: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "weeklike_gaps: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "weeklike_gaps: quality restored");
}
// Case 45: quiet_recent_window; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case45()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = (I < 24 ? 0. : 0.001 * sin(0.27 * I));
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "quiet_recent_window: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "quiet_recent_window: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "quiet_recent_window: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "quiet_recent_window: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_recent_window: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "quiet_recent_window: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[104] = 2.;
    TS2Expect(TS2Evaluate() == 0., "quiet_recent_window: implausible return rejected");
    TS2Expect(TS2Quality == 0., "quiet_recent_window: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "quiet_recent_window: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_recent_window: quality restored");
}
// Case 46: quiet_old_window; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case46()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = (I > 180 ? 0. : 0.001 * sin(0.27 * I));
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "quiet_old_window: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "quiet_old_window: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "quiet_old_window: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "quiet_old_window: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_old_window: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "quiet_old_window: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[141] = 2.;
    TS2Expect(TS2Evaluate() == 0., "quiet_old_window: implausible return rejected");
    TS2Expect(TS2Quality == 0., "quiet_old_window: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "quiet_old_window: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_old_window: quality restored");
}
// Case 47: unequal_tail_mass; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case47()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = (I % 13 == 0 ? -0.004 : 0.00035 + 0.0001 * sin(I));
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "unequal_tail_mass: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "unequal_tail_mass: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "unequal_tail_mass: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "unequal_tail_mass: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "unequal_tail_mass: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "unequal_tail_mass: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[178] = 2.;
    TS2Expect(TS2Evaluate() == 0., "unequal_tail_mass: implausible return rejected");
    TS2Expect(TS2Quality == 0., "unequal_tail_mass: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "unequal_tail_mass: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "unequal_tail_mass: quality restored");
}
// Case 48: bounded_chaotic_phase; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case48()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.001 * sin(I * I * 0.61803398875);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "bounded_chaotic_phase: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "bounded_chaotic_phase: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "bounded_chaotic_phase: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "bounded_chaotic_phase: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "bounded_chaotic_phase: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "bounded_chaotic_phase: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[215] = 2.;
    TS2Expect(TS2Evaluate() == 0., "bounded_chaotic_phase: implausible return rejected");
    TS2Expect(TS2Quality == 0., "bounded_chaotic_phase: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "bounded_chaotic_phase: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "bounded_chaotic_phase: quality restored");
}
void TS2SelfTest()
{
    int I;
    TS2Checks = 0;
    TS2Failures = 0;
    file_write(TS2TestLog, "Synthetic property suite\n", 0);
    for (I = 0; I < 256; I++)
        TS2Returns[I] = 0.;
    TS2Expect(TS2Evaluate() == 0., "flat path has no edge");
    TS2Expect(TS2Quality == 0., "flat path clears quality");
    TS2KnownResponse();
    TS2Case1();
    TS2Case2();
    TS2Case3();
    TS2Case4();
    TS2Case5();
    TS2Case6();
    TS2Case7();
    TS2Case8();
    TS2Case9();
    TS2Case10();
    TS2Case11();
    TS2Case12();
    TS2Case13();
    TS2Case14();
    TS2Case15();
    TS2Case16();
    TS2Case17();
    TS2Case18();
    TS2Case19();
    TS2Case20();
    TS2Case21();
    TS2Case22();
    TS2Case23();
    TS2Case24();
    TS2Case25();
    TS2Case26();
    TS2Case27();
    TS2Case28();
    TS2Case29();
    TS2Case30();
    TS2Case31();
    TS2Case32();
    TS2Case33();
    TS2Case34();
    TS2Case35();
    TS2Case36();
    TS2Case37();
    TS2Case38();
    TS2Case39();
    TS2Case40();
    TS2Case41();
    TS2Case42();
    TS2Case43();
    TS2Case44();
    TS2Case45();
    TS2Case46();
    TS2Case47();
    TS2Case48();
    file_append(TS2TestLog, strf("RESULT: %d checks; %d failures\n", TS2Checks, TS2Failures));
}

// Embedded execution and risk controls; no custom runtime include is required.
function run()
{
    int Index;
    var Current, Previous, Edge, Sigma, Amount, UnitRisk, Budget;
    BarPeriod = 60;
    LookBack = 260;
    StartDate = 20240101;
    EndDate = 20241231;
    Capital = 10000.;
    Hedge = 0;
    MaxLong = 1;
    MaxShort = 1;
#ifdef TS2_SELFTEST
    if (is(INITRUN))
    {
        TS2SelfTest();
        quit("TS2 synthetic tests complete; no historical or live orders");
    }
    return;
#endif
    if (!asset("EUR/USD"))
        return;
    algo(TS2Algo);
    if (is(EXITRUN) || is(LOOKBACK))
        return;
    for (Index = 0; Index < TS2_N; Index++)
    {
        Current = priceClose(Index + 1);
        Previous = priceClose(Index + 2);
        if (!(Current > 0.) || !(Previous > 0.))
        {
            exitLong();
            exitShort();
            return;
        }
        TS2Returns[Index] = log(Current / Previous);
    }
    Edge = TS2Evaluate();
    plot("model edge", Edge, NEW, BLUE);
    plot("model quality", TS2Quality, 0, RED);
    if (Edge < 0.10 || TS2Quality < 0.15)
        exitLong();
    if (Edge > -0.10 || TS2Quality < 0.15)
        exitShort();
    if (abs(Edge) < 0.25 || TS2Quality < 0.30)
        return;
    if (NumOpenLong + NumOpenShort > 0)
        return;
    if (PIP <= 0. || PIPCost <= 0. || LotAmount <= 0. || MarginCost <= 0.)
        return;
    if (Balance <= 0. || Equity < 0.85 * Balance)
        return;
    Sigma = 0.;
    for (Index = 0; Index < 48; Index++)
        Sigma += TS2Returns[Index] * TS2Returns[Index] / 48.;
    Sigma = sqrt(Sigma) * priceClose(1);
    Stop = max(20. * PIP, 3. * Sigma);
    TakeProfit = 2. * Stop;
    LifeTime = TS2Holding;
    UnitRisk = (Stop + abs(Spread)) / PIP * PIPCost;
    UnitRisk += abs(Commission) * LotAmount / 10000.;
    if (UnitRisk <= 0.)
        return;
    Budget = 0.0025 * min(Balance, Equity);
    Amount = min(Budget / UnitRisk, 2000. / LotAmount);
    Amount = min(Amount, max(0., Equity - MarginVal) * 0.5 / MarginCost);
    if (Amount < 1.)
        return;
    Lots = floor(Amount);
    Risk = 0.;
    Margin = 0.;
    if (Edge > 0.)
        enterLong();
    else
        enterShort();
}