<|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.

444. Headstrong Student
Time limit per test: 0.75 second(s)
Memory limit: 262144 kilobytes
input: standard
output: standard

You are a teacher at a cram school for elementary school pupils. One day, you showed your students how to calculate division of fraction in a class of mathematics. Your lesson was kind and fluent, and it seemed everything was going so well — except for one thing. After some experiences, a student Max got so curious about how precise he could compute the quotient. He tried many divisions asking you for a help, and finally found a case where the answer became an infinite fraction. He was fascinated with such a case, so he continued computing the answer. But it was clear for you the answer was an infinite fraction — no matter how many digits he computed, he wouldn't reach the end. Since you have many other things to tell in today's class, you can't leave this as it is. So you decided to use a computer to calculate the answer in turn of him. Actually you succeeded to persuade him that he was going into a loop, so it was enough for him to know how long he could compute before entering a loop. Your task now is to write a program which computes where the recurring part starts and the length of the recurring part, for given dividend/divisor pairs. All computation should be done in decimal numbers. If the specified dividend/divisor pair gives a finite fraction, your program should treat the length of the recurring part as 0.
Input
The input consists of a line containing two positive integers x and y, which specifies the dividend and the divisor, respectively. You may assume that 1 ≤ x,y ≤ 1000000.
Output
Your program should output a line containing two integers separated by exactly one blank character. The former describes the number of digits after the decimal point before the recurring part starts. And the latter describes the length of the recurring part.
Example(s)
sample input
sample output
1 3
0 1

sample input
sample output
1 6
1 1

sample input
sample output
5 3
0 1

sample input
sample output
5 4
2 0

sample input
sample output
200 2
0 0

sample input
sample output
25000 99
0 2

<|response|>
1. Abridged Problem Statement  
   You are given two positive integers x (numerator) and y (denominator). Consider the decimal expansion of the fraction x/y.  
   – If it terminates, report how many digits appear after the decimal point (the non-repeating part) and report 0 for the repeating‐cycle length.  
   – If it does not terminate, determine where the repeating cycle of digits begins (the count of non‐repeating digits) and how many digits are in that cycle.

2. Key Observations  
   – When you do long division of x by y in base 10, you repeatedly carry down zeros and compute new remainders.  
   – Let r₀ = x mod y be the initial remainder after removing the integer part.  
   – At each step k, you multiply the previous remainder rₖ by 10, divide by y to get the next digit, and take rₖ₊₁ = (rₖ * 10) mod y.  
   – If at some step rₖ becomes 0, the decimal expansion terminates.  
   – Otherwise, there are at most y−1 nonzero remainders, so some remainder must eventually repeat. When a remainder r repeats, the block of digits between its first occurrence and the current step is the repeating cycle.  
   – By recording the first step index at which each remainder appears, you can detect both the start and the length of the cycle.

3. Full Solution Approach  
   1. Compute the initial remainder:  
         rem = x % y  
      If rem == 0, the fraction is exact; it terminates immediately with 0 digits before repeating and cycle length 0.  
   2. Create an array (or vector) visited of size y, initialized to –1.  
      visited[r] will store the step index (0-based) when remainder r first appeared.  
   3. Initialize step = 0. This counts how many decimal digits we have produced so far.  
   4. While rem ≠ 0 and visited[rem] == –1:  
         – record visited[rem] = step  
         – produce the next remainder: rem = (rem * 10) % y  
         – increment step  
   5. After the loop, two cases arise:  
      a. rem == 0 → the division terminated after step digits.  
         • non_repeating = step  
         • cycle_length = 0  
      b. rem ≠ 0 and visited[rem] ≥ 0 → we found a cycle.  
         • the cycle starts at index visited[rem]  
         • non_repeating = visited[rem]  
         • cycle_length = step − visited[rem]  
   6. Output non_repeating and cycle_length.

   Time complexity: O(y) steps in the worst case  
   Space complexity: O(y) for the visited array

4. C++ Implementation with Detailed Comments  
```cpp
#include <bits/stdc++.h>
using namespace std;

// Returns a pair: (non_repeating_length, cycle_length)
pair<int,int> analyze_decimal(int x, int y) {
    // If x is a multiple of y, the decimal terminates immediately.
    if (x % y == 0) {
        return {0, 0};
    }

    // visited[r] = the step index when remainder r first appeared
    vector<int> visited(y, -1);

    int rem = x % y;      // initial remainder
    int step = 0;         // number of digits produced so far

    // Simulate the long division until we terminate or detect a repeat
    while (rem != 0 && visited[rem] == -1) {
        visited[rem] = step;       // mark the current remainder
        rem = (rem * 10) % y;      // compute next remainder
        step++;                    // one more digit produced
    }

    // Case 1: remainder became zero → terminated decimal
    if (rem == 0) {
        // All 'step' digits are non-repeating; cycle length = 0
        return {step, 0};
    }

    // Case 2: remainder repeated → cycle detected
    int start = visited[rem];      // where the cycle began
    int cycle_len = step - start;  // length of repeating part
    return {start, cycle_len};
}

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

    int x, y;
    cin >> x >> y;

    auto result = analyze_decimal(x, y);
    // Print: [digits before cycle] [length of cycle]
    cout << result.first << ' ' << result.second << "\n";
    return 0;
}
```

5. Python Implementation with Detailed Comments  
```python
def analyze_decimal(x, y):
    # If x is exactly divisible by y, there's no fractional part.
    if x % y == 0:
        return 0, 0

    # visited[r] = the index of the digit (0-based) when remainder r first appeared
    visited = [-1] * y

    rem = x % y   # initial remainder after integer part
    step = 0      # how many decimal digits produced so far

    # Simulate long division
    while rem != 0 and visited[rem] == -1:
        visited[rem] = step
        rem = (rem * 10) % y
        step += 1

    # If remainder became zero, decimal expansion terminated
    if rem == 0:
        return step, 0

    # Otherwise, we have a cycle
    start = visited[rem]         # the index where the cycle starts
    cycle_len = step - start     # length of the repeating cycle
    return start, cycle_len

def main():
    x, y = map(int, input().split())
    non_repeating, cycle_length = analyze_decimal(x, y)
    print(non_repeating, cycle_length)

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