1. Abridged Problem Statement
Given a principal s, a term of m months, and a monthly interest rate p percent, compute the fixed annuity payment x so that after m equal payments the debt is fully repaid. Output x with an absolute error up to 1e-5.

2. Detailed Editorial
We want a constant monthly payment x such that, if the remaining debt before month i is Sᵢ, then each month:
  – interest portion: aᵢ = (p/100) · Sᵢ
  – principal portion: bᵢ = x – aᵢ
  – next debt: Sᵢ₊₁ = Sᵢ – bᵢ

We must have S₁ = s and Sₘ₊₁ = 0.

Case p = 0: no interest accrues, so x = s / m.

Case p > 0: let r = p/100. We can write the update
  Sᵢ₊₁ = Sᵢ – (x – r·Sᵢ) = (1 + r)·Sᵢ – x.

Unrolling this recurrence for m steps yields
  Sₘ₊₁ = (1 + r)ᵐ·s – x·[ (1 + r)ᵐ⁻¹ + (1 + r)ᵐ⁻² + … + 1 ].

We require Sₘ₊₁ = 0, so
  x · [((1 + r)ᵐ – 1)/r] = (1 + r)ᵐ · s
⇒ x = s · [r·(1 + r)ᵐ] / [ (1 + r)ᵐ – 1 ].

Compute (1 + r)ᵐ via fast exponentiation (pow), then apply the formula in O(1) time.
Be careful with floating-point precision; use double and set output precision to five decimal places.

3. C++ Solution
```cpp
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int64_t s, m, p;

void read() {
    cin >> s >> m >> p;
}

void solve() {
    // Annuity payment: each month the same x is paid, of which p% of the
    // current debt is interest and the rest reduces the principal, so the debt
    // must reach 0 after m months. With monthly rate r = p/100 the standard
    // annuity formula gives x = s * r * (1+r)^m / ((1+r)^m - 1). When p = 0
    // there is no interest and the payment is simply s / m.

    double x;
    if(p == 0) {
        x = (double)s / m;
    } else {
        double r = p / 100.0;
        double pw = pow(1 + r, (double)m);
        x = s * (r * pw) / (pw - 1);
    }

    cout << fixed << setprecision(5) << x << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}
```

4. Python Solution
```python
import sys

def find_monthly_payment(s, m, p):
    """
    Calculate the fixed annuity payment per month.
    s: principal (float or int)
    m: number of months (int)
    p: monthly interest percentage (float)
    """
    # If there's no interest, split the principal evenly
    if p == 0:
        return s / m

    # Convert percentage to decimal rate
    r = p / 100.0
    # Compute (1 + r)^m
    factor = (1 + r) ** m
    # numerator = r * (1 + r)^m
    numerator = r * factor
    # denominator = (1 + r)^m - 1
    denominator = factor - 1.0
    # Annuity payment formula
    x = s * numerator / denominator
    return x

def main():
    # Read three values from standard input
    data = sys.stdin.read().strip().split()
    s, m, p = map(float, data)  # m can be float-cast but behaves as int
    m = int(m)
    # Compute payment
    x = find_monthly_payment(s, m, p)
    # Output with 5 decimal places
    print(f"{x:.5f}")

if __name__ == "__main__":
    main()
```

5. Compressed Editorial
- If p=0, answer is s/m.
- Else let r=p/100; compute factor=(1+r)^m.
- Use x = s·[r·factor]/(factor−1).
- Print x with five decimal digits.
