<|instruction|>
Solve the below problem. The solution should start with an abridged problem statement. Then key observations. Then full solution based on the observations. Then C++ and Python implementations with comments.

456. Annuity Payment Scheme
Time limit per test: 0.5 second(s)
Memory limit: 65536 kilobytes
input: standard
output: standard



At the peak of the Global Economic Crisis BerBank offered an unprecedented credit program. The offering was so attractive that Vitaly decided to try it. He took a loan of s burles for m months with the interest rate of p percent.

Vitaly has to follow the scheme of annuity payments, meaning that he should make fixed monthly payments — x burles per month. Obviously, at the end of the period he will pay m · x burles to the bank in total.

Each of the monthly payments is divided by BerBank into two parts as follows:
The first part ai is used to pay off the percent p of the current debt. It's clear that ai=s' · p / 100 where s'=s for the first month and equals to the remaining debt for each of the subsequent months.
The second part bi is used to pay off the current debt. The sum of all bi over the payment period is equal to s, meaning that the borrower needs to pay off the debt completely by decreasing it from s to 0 in m months.
BerBank uses calculations with floating-point numbers, and the value of x is uniquely determined by s,m and p.

For example, if s=100, m=2, p=50 then x=90. For the first month a1 = s' · p / 100 = s · p / 100 = 50 and b1 = 90 - 50 = 40. For the second month a2 = (100-40) · 50 / 100 = 30, so b2 = 90 - 30 = 60 and the debt is paid off completely.

Your task is to help Vitaly and write a program that computes x given the values of s,m and p.

Input
The single line of the input contains three integers s, m and p (1 ≤ s ≤ 106, 1 ≤ m ≤ 120, 0 ≤ p ≤ 100).

Output
Output the single value of monthly payment x in burles. An absolute error of up to 10-5 is allowed.

Example(s)
sample input
sample output
100 2 50
90.00000

<|response|>
1. Abridged problem statement  
Given a principal s, a loan term of m months, and a monthly interest rate p (percent), compute the fixed monthly annuity payment x so that after m equal payments the outstanding debt becomes zero. Output x with absolute error up to 1e-5.

2. Key observations  
- If the interest rate p is zero, there is no interest, so the borrower simply divides the principal by the number of months: x = s / m.  
- If p > 0, each month the outstanding balance Sᵢ grows by interest and then is reduced by the payment:  
  Sᵢ₊₁ = Sᵢ + (p/100)·Sᵢ – x = (1 + r)·Sᵢ – x,  where r = p/100.  
- After m such steps we need Sₘ₊₁ = 0. Unfolding the recurrence yields a geometric progression in (1 + r).  
- The closed-form formula for the annuity payment is  
  x = s · [r·(1+r)ᵐ] / [(1+r)ᵐ – 1].  

3. Full solution approach  
a. Read inputs s, m, p.  
b. If p = 0, compute x = s / m.  
c. Otherwise let r = p/100.  
   i.   Compute factor = (1 + r)ᵐ using fast exponentiation or the language's pow.  
   ii.  Numerator = r * factor.  
   iii. Denominator = factor – 1.  
   iv.  x = s * Numerator / Denominator.  
d. Print x with five digits after the decimal point.

4. C++ implementation with detailed comments  
#include <bits/stdc++.h>
using namespace std;

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

    // Read principal s, number of months m, monthly interest percent p
    double s;
    int m;
    double p;
    cin >> s >> m >> p;

    double x;
    if (p == 0.0) {
        // No interest: equal division of principal
        x = s / m;
    } else {
        // Convert percent to decimal rate
        double r = p / 100.0;
        // Compute (1 + r)^m
        double factor = pow(1.0 + r, m);
        // Apply annuity formula: x = s * [r*factor] / [factor - 1]
        x = s * (r * factor) / (factor - 1.0);
    }

    // Output with fixed format and five decimals
    cout << fixed << setprecision(5) << x << "\n";
    return 0;
}

5. Python implementation with detailed comments  
import sys

def find_monthly_payment(s, m, p):
    """
    Calculate fixed monthly annuity payment.
    s: principal (float)
    m: number of months (int)
    p: monthly interest rate in percent (float)
    """
    if p == 0.0:
        # No interest case
        return s / m
    # Convert percent to decimal
    r = p / 100.0
    # Compute (1 + r)^m
    factor = (1.0 + r) ** m
    # Apply annuity formula
    return s * (r * factor) / (factor - 1.0)

def main():
    # Read input from stdin
    data = sys.stdin.read().strip().split()
    s, m, p = float(data[0]), int(data[1]), float(data[2])
    # Compute the payment
    x = find_monthly_payment(s, m, p)
    # Print with five decimal places
    print(f"{x:.5f}")

if __name__ == "__main__":
    main()