<problem>
Create a function `fibonacci(n:int)` that takes in a parameter `n`, an integer representing the number of terms in the Fibonacci sequence to generate, and returns:
-  'OOPS', if `n` is less than or equal to 0 
- `1`  if `n` is equal to `1`
- `1` if `n` is equal to `2`
- Otherwise, return the nth term of the Fibonacci sequence. A Fibonacci sequence is a sequence in which every number is the sum of the previous two numbers in the sequence. Example Fibonacci sequence: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ....
## Example Cases:
```
fibonacci(-3) => 'OOPS'
fibonacci(0) => 'OOPS'
fibonacci(1) =>1
fibonacci(2) => 1
fibonacci(5) => 5
fibonacci(10) => 55
```
</problem>
<bug_code>
1. def fibonacci(n):
2.    if n <= 0:
3.        return "OOPS"
4.    elif n == 1 or n == 2:
5.        return 1
6.    else:
7.        return fibonacci(n) + fibonacci(n-1)
</bug_code>
<bug_desc>
`fibonacci(n)` calls `fibonacci(n)` on line 7 with the same argument `n` which leads to infinite recursion and consequently a runtime error is thrown.
</bug_desc>
<bug_fixes>
Replace `fibonacci(n) + fibonacci(n-1)` with `fibonacci(n-1) + fibonacci(n-2)` on line 7.
</bug_fixes>
<unit_tests>
assert fibonacci(0) == 'OOPS'
assert fibonacci(1) == 1
assert fibonacci(2) == 1
assert fibonacci(5) == 5
assert fibonacci(-3) == 'OOPS'
assert fibonacci(10) == 55
</unit_tests>
<stu_desc>

</stu_desc>
<dialogue>
User: Hi! My code returns a runtime error about infinite recursion, whenever I give it an input number greater than 2. Can you help?
Assistant: I assume this means you tried it with values 1 and 2 for the input `n` and it worked. Given this, which line in the code do you think is responsible for the runtime error?
	<alt>According to the problem description, the nth number in the Fibonacci sequence should be equal to the sum of Fibonacci numbers at what positions?
	<alt>According to the definition of Fibonacci numbers given in the problem description, how is the number at position `n` computed?
	<alt>Can you explain what infinite recursion means?
	<alt>Assume that the input `n` is 3. Can you tell me what the code does in this case, by going over it line by line?
	<alt>Given the error is about 'infinite recursion', can you tell me where recursion happens in your code?
	<alt>Can you explain what a recursive function is? When do we call a function recursive?
	<alt>According to the problem description, every Fibonacci number is the sum of the previous two numbers in the sequence. Therefore, what Fibonacci number do you get if you add the numbers at positions `n` and `n - 1`?
User: I believe it is line 7, because that is the line that is executed when `n` is larger than 2.
Assistant: That is correct. Assume that the input `n` is 3, so the initial function call is `fibonacci(3)`. Can you tell me what is the first thing that happens in line 7 in this case?
	<alt>Correct. So, when `fibonacci(n)` is evaluated, if n is larger than 2, line 7 is executed. What is the first thing that happens on line 7?
	<alt>Correct. According to the problem description, what Fibonacci number do you get if you add the numbers at positions `n` and `n - 1`, as you do on line 7?
User: Well, the function is called recursively to compute `fibonacci(3)`.
	<alt>Well, the function is called recursively to compute `fibonacci(3)`. Ah, I see now! When `n` is 3,  `fibonacci(3)` calls itself again on line 7 with the same value 3, and this leads to an infinite number of calls to `fibonacci(3)`.
	<alt>Well, the function is called recursively to compute `fibonacci(3)`. Ah, I see now! When `n` is 3,  `fibonacci(3)` calls itself again on line 7 with the same value 3, and this leads to an infinite number of calls to `fibonacci(3)`. Oh, this is because I used the wrong parameters for the recursive calls. Let me fix it...
<code>
1. def fibonacci(n):
2.    if n <= 0:
3.        return "OOPS"
4.    elif n == 1 or n == 2:
5.        return 1
6.    else:
7.        return fibonacci(n - 1) + fibonacci(n - 2)

</code>
	<alt>The call `fibonacci(n)`.
Assistant: So, when you call `fibonacci(3)`, the code gets to line 7 where the first thing that happens is a new call to `fibonacci(3)`. What do you think happens when this new `fibonacci(3)` call is executed, line by line?
	<alt>Do you see now why infinite recursion happens?
	<alt>So, when you call `fibonacci(3)`, eventually it gets to line 7 where `fibonacci(3)` is called again. Do you see now why infinite recursion happens?
User: Well, since n is 3, line 7 is executed again, which means that `fibonacci(3)` is evaluated again. I think I got it, `fibonacci(n)` calls itself recursively with the same parameter `n`, which leads to infinite recursion. I made mistake, I should have added the previous Fibonacci numbers, which are those at positions `n - 2` and `n - 1`. Let me try it... it works!
<code>
1. def fibonacci(n):
2.    if n <= 0:
3.        return "OOPS"
4.    elif n == 1 or n == 2:
5.        return 1
6.    else:
7.        return fibonacci(n - 2) + fibonacci(n - 1)

</code>
Assistant: Great, your program now works as expected!
User: Thank you so much!
Assistant: You are welcome!
</dialogue>