[Question]
  [
Your task is to write a piece of code that zeros the current cell in the Brainfuck variant that, each cell can contain a **signed** integer of arbitrarily large magnitude, instead of the normal 0 to 255.
You may assume there are *l* cells to the left and *r* cells to the right of the current cell that are initially zero. You program may only access these *l*+*r*+1 cells. After your code ends it should leave the *l*+*r* extra cells zero and the pointer to the current cell at the original position.
You may not use any input/output.
The code with smallest *l*+*r* wins. If there is a tie, the shortest code wins. It is recommended to also state the time complexity of your program for reference, where *n* is the absolute value of the original integer in the current cell.
### Useful tools
You can test a Brainfuck program in this variation using [this interpreter on TIO by mbomb007](https://tio.run/nexus/python2#fVG7boMwFJ3xV1h0sCkBOUNVicaR2kzZ2RADGFdY5WEZR2k/vHN6sSktHTrZ93Au5@EwDNHzxbajyXBfj33N2CMKATxxQwi57Yp0V97gVuyzZF8i1evRWDx9TCjnBSvvHxhDZ96pyVIA08k2akiNrBoaRUhwzRm6tqqTWBw6OdBTlKGg5qdClChQr7jmnBwJYIGO@R4OwPSRz9Q8yvJ41Qhkt9APnp6s9APLYBlIT6ulOP@1EJMsL3Tp/r@CiQeTDZiSbAkxXmx6NcpKKlpDZybE@SEWzgMM8xfO2TwFnXMU@Ljd0YOB8LkcW/hkUIJ8V5aSF1OJN2lxr6a@sqIl0TdzLsjrdN/7TnzBS8C31kvnyFvYOhC@KacPVf2nvBVe9v7qej9iK7/zdfIzroYGj6ah51SPmrIoggnD@7ke0J02arCutvV@q2rxOYyJqEQrvwA).
You can also use the interpreter in [this answer by boothby](https://codegolf.stackexchange.com/a/3085/25180) (other Python answers probably also work, but I didn't test).
  
[Answer]
# l+r = 0+2 = 2, ~~55~~ ~~53~~ 51 bytes
```
[>+[-<+>>+<]<[>]>[+[-<+<->>]<[->+<]]>[-<+>]<<]>[-]<
```
# l+r = 1+2 = 3, ~~46~~ 44 bytes
```
[[>+[-<+<+>>]<[<+[->->+<<]]>]>[>]<[-]<<[-]>]
```
My own algorithm. The pointer should begin at the number that needs to be zeroed. The time complexity is O(n^2).
### How it works:
* We start with the number `n`.
* We increment one, so the number becomes `n+1`.
* We decrement two, so the number becomes `n+1-2 = n-1`
* We increment three, so the number becomes `n-1+3 = n+2`.
* We decrement four, so the number becomes `n+2-4 = n-2`.
We repeat the process, increasing the in-/decrement each step, until we get zero.
[Answer]
# l + r = 0 + 2 = 2; 58 bytes
```
>+<[>[<->>+<-]>+<<[>]>[<<+>+>-]<[->+<]>[<]>+[-<+>]<<]>[-]<
```
The complexity is O(n^2).
The following is my testing program generator, so you can see that I actually tried to test it in case it doesn't work...
```
p='''
>+<
[
>
[<->>+<-]
>+<
<[>]>
[<<+>+>-]
<
[->+<]
>[<]>
+ [-<+>]
<<
]
> [-] <
'''
p = ''.join(p.split())
cpp = '''
#include <bits/stdc++.h>
using namespace std;
void test(int q) {
long long t[3] = {q, 0, 0};
int i = 0;
ZZZ
printf("q=%d %lld %lld %lld\\n", q, t[0], t[1], t[2]);
}
int main() {
while(true) {
    int q; cin >> q; test(q);
}
}
'''
d = {
'>': '++i; assert(i<3);',
'<': '--i; assert(i>=0);',
'+': '++t[i];',
'-': '--t[i];',
'[': 'while(t[i]){',
']': '}',
}
print cpp.replace('ZZZ', ''.join(d[c] for c in p))
```
]