[Question]
  [
## Challenge
Let's have a list `L` of `n` elements. The task is to swap every two elements in this list.
## Constrains
* the list `L` has at least two elements
* size of the list `L` is a multiple of two (i.e. number of elements is even)
### Example
* input: `[1,2,3,4,5,6]`
* output: `[2,1,4,3,6,5]`
* input: `[0,1,0,1]`
* output: `[1,0,1,0]`
## Rules
* this is `code-golf` challenge, so the shortest code wins
* [standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer with [default I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/), so you are allowed to use stdin/stdout, functions/method with the proper parameters and return-type, full programs
* [default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
  
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~4~~ 3 bytes
```
i#o
```
[Try it online!](https://tio.run/##S8sszvj/PzMzP///f0MjYxNTMwA "><> ‚Äì Try It Online")
Lol, ><> ~~ties with~~ beats Jelly & 05AB1E. Terminates with an error.
-1 thanks to @Manny Queen.
# How does it work?
```
     The instruction pointer (IP) is currently moving right
i    Take input as a character
 #   Reflect - The IP starts moving left
i    Take input again
  o  Output that
 #   Reflect - The IP starts moving right again
  o  Output the first input we took - the inputs are now swapped
And now, we're moving left and back at the start again on i + moving right. 
This loops forever (i.e. until erroring when we're out of input) 
because there is no halt instruction (;)
This is essentially executing "iioo" in an infinite loop.
```
[Answer]
# [Python 3](https://docs.python.org/3/), 34 bytes
```
f=lambda l:l and l[1::-1]+f(l[2:])
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P802JzE3KSVRIccqRyExL0UhJ9rQykrXMFY7TSMn2sgqVvN/QVFmXolGmka0oY6RjrGOiY6pjlmspuZ/AA "Python 3 ‚Äì Try It Online")
When `l` is empty (which makes it falsy), return it directly. Otherwise, reverse the first two elements and make a recursive call for the rest.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `r`, 2 bytes
```
yY
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=r&code=yY&inputs=%5B1%2C2%2C3%2C4%2C5%2C6%5D&header=&footer=)
Explanation:
```
y  # Uninterleave
 Y # Interleave
```
[Answer]
# [Haskell](https://www.haskell.org/), 22 bytes
```
f(a:b:c)=b:a:f c
f x=x
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00j0SrJKlnTNskq0SpNIZkrTaHCtuJ/bmJmnoKtQkq@ApdCQVFmXomCikJatKGenlksioCOgQ4Ux/4HAA "Haskell ‚Äì Try It Online")
[Answer]
# [convey](http://xn--wxa.land/convey/), 7 bytes
I knew I should have implemented SpaceChem's flipflop operator, then this would be 5 bytes. :-)
*-6 byte by @Manny Queen*
```
}?{
}~1
```
[Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoifT97XG59fjEiLCJ2IjoxLCJpIjoiMSAyIDMgNCA1IDYifQ==)
`{` puts the input list on the conveyor, `}` prints the result. On the `?` the elements try to go down if they can. On the `~` they will wait for `1` tick before going to the output, thus starting with the first item, every second element is delayed for two ticks.
### 13 bytes
```
},<
{@^
0"
1^
```
[Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoifSw8XG57QF5cbjBcIlxuMV4iLCJ2IjoxLCJpIjoiMSAyIDMgNCA1IDYifQ==)
The lower loop `0"\1^` copies `0 1 0 1 ‚Ä¶` into choose `@`. The input is thus split into two paths. The right one takes a little bit longer, so the other number can overtake it before joining `,` again.
[![variant 2 with input 1 to 6](https://i.stack.imgur.com/d4SqQ.gif)](https://i.stack.imgur.com/d4SqQ.gif)
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 9 bytes
```
,[>,.<.,]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fJ9pOR89GTyf2/39DI2MTUzMA "brainfuck ‚Äì Try It Online")
[Answer]
# [Rust](https://www.rust-lang.org/) v1.37.0, ~~59~~ ~~55~~ 47 bytes
```
|a:&[_]|(0..).zip(a).map(|i|a[i.0^1]).collect()
```
[Try it online!](https://tio.run/##Lc1NDoIwFATgtZ7iyYK0ybPhR12g4C3cEDQNwaRJKQ2UmEg5e63AajbfzPTjYNxbQcuFIhSm/U42BoYP10PuLM/C8lVZEjFG2VdowilruSZWWF4KFj3jirK6k7KpDaHuuraF0qOBHMoYIUFIEU4IZ4RLtYFuNF5k8Gjqm0iTwtvlkYRLlXqme6GMVAcSTNl9hmMB/wxwHcdtwsvZ/QA "Rust ‚Äì Try It Online")
*-2 bytes thanks to ZippyMagician*  
*-2 bytes thanks to alephalpha*  
*-8 bytes thanks to `(0..).zip(a)`*
Rust is not a golfy language...  
Port of the [C#](https://codegolf.stackexchange.com/a/237101/44998) and [JS](https://codegolf.stackexchange.com/a/237108/44998) answers  
v1.37.0 is the version available on TIO
# [Rust](https://www.rust-lang.org/) stable, 54 bytes
```
|a:&[_]|a.chunks(2).flat_map(|a|[a[1],a[0]]).collect()
```
[Try it online!](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=303e751fa22451f42bc9f876119481cd)
Thanks to ZippyMagician for this *slightly* golfier answer on the latest version of Rust.
[Answer]
# [Python 2](https://docs.python.org/2/), 30 bytes
```
def f(a,b,*m):print b,a,;f(*m)
```
[Try it online!](https://tio.run/##HYs7DsMgEAV7TrElWK8IzqcgtW@QznJhJ4uMlGCENrI5PUEpphnNpCLrFvtaX@zJ6xkLuo9xKYcotGDG3esm6r6GN5N1iiQX18ouxPQVbYwiPp6chB4l8ZDzlh399zpa9DjjgitukxpPsGhMPw "Python 2 ‚Äì Try It Online")
The function `f` takes input splatted like `f(1,2,3,4,5,6)`, and prints the output space-separated, terminating with error.
---
**34 bytes**
```
lambda l:map(l.pop,len(l)/2*[1,0])
```
[Try it online!](https://tio.run/##DcpLCoAgEADQfadwqTGU2mchdJJyYVQojDaEEZ3eWr9Hb/Zn0uWYloIurptjaKIjjg2dBLgnjqLV9axAWlEeH3BnytAVUmYHD4nuzIUov2vooIcBRlvNEv4Pyn4 "Python 2 ‚Äì Try It Online")
This works by alternating popping the elements at index `1` and index `0`.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 22 bytes
```
0<##<1||#2&&#&&#0@##3&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b738BGWdnGsKZG2UhNTRmIDByUlY3V/geWZqaWOAQUZeaVRCvr2qU5OCjHqtUFJyfm1VVzVRvqGOkY65jomOqY1epwVRvoGOoAMYRpUMtV@x8A "Wolfram Language (Mathematica) ‚Äì Try It Online")
Input `[L...]`, and returns in an `And`. Works on integer inputs.
---
### [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 24 bytes
```
{}=={##}||#2&&#&&#0@##3&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7v7rW1rZaWbm2pkbZSE1NGYgMHJSVjdX@B5ZmppY4BBRl5pVEK@vapTk4KMeq1QUnJ@bVVXNVG@oY6RjrmOiY6pjV6nBVG@gY6gAxhGlQy1X7HwA "Wolfram Language (Mathematica) ‚Äì Try It Online")
Input `[L...]`, and returns in an `And`. Works on non-boolean inputs.
### [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 26 bytes
```
#2~##&~#&@@@#~Partition~2&
```
[Try it online!](https://tio.run/##DcM7CoAwDADQvdcIdIqg9bMpOULBURxCUexgBclWmqtXH7yb5Tpulhi4nnMFpwBWwRIRqOdXosQnqbPVvzHJBs1yEuxW18BJs8kdOuxxwBGngia32OG/mFI/ "Wolfram Language (Mathematica) ‚Äì Try It Online")
Input `[L]`, and returns a list. Works.
[Answer]
# JavaScript (ES6), 23 bytes
```
x=>x.map((_,i)=>x[i^1])
```
The `[i^1]` is thanks to m90 in TNB
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z@TWqJQXJ5YUGz7P9HWLlEvN7FAQyNeJ1MTyInOjDOM1QQrycwrKC1RsFWINtQx0jHWMdEx1TGLteZKzs8rzs9J1cvJT9dIUKkGq6pV0LVTUKkGG6oBFtGsTdC0/g8A)
[Answer]
# [Python 3](https://docs.python.org/3/), 36 bytes
```
lambda a:sum(zip(a[1::2],a[::2]),())
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHRqrg0V6Mqs0AjMdrQysooVicxGkRp6mhoav4vKMrMK9FI04g21DHSMdYx0THVMYsFigMA "Python 3 ‚Äì Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/) + numpy, 31 bytes
```
lambda m:m[~-(m==m).cumsum()^1]
```
[Try it online!](https://tio.run/##XcqxDoIwEADQna/oeJecREQdNP0SwOTAEEm841LaoQu/Xp0Z3vYsx8@qbZl9X74s45udPKTbTyDeC9ZTki0J4KsZyiK2hug0iWXHm1OrKvZqNYfAGbqGLtTSlW50H/BpYdEITDMw4uGd6e94yg8 "Python 3 ‚Äì Try It Online")
Expects a numpy array. Most of the code is about avoiding referencing numpy directly, so we can avoid the explicit import. It then calculates the indices directly by xoring a counter with 1.
[Answer]
# [Ly](https://github.com/LyricLy/Ly), 7 bytes
```
ir[foo]
```
[Try it online!](https://tio.run/##y6n8/z@zKDotPz/2/39DI2MTUzNzCwA "Ly ‚Äì Try It Online")
Pretty straightforward, but might be worth posting since it's almost pronounceable. :)
```
ir       -- read input codepoints into the stack, reverse the order
  [   ]  -- while the stack isn't empty
   foo   -- flip the top two entries and print as characters
```
# [Cubix](https://github.com/ETHproductions/cubix), 14 bytes
```
[[email protected]](/cdn-cgi/l/email-protection)?i.o;o;.^
```
[Try it online!](https://tio.run/##Sy5Nyqz4/19Pz0Ev0z5TL98631ov7v9/QyNjE1MzcwsA "Cubix ‚Äì Try It Online")
This is the first time I've tried to use Cubix, so I wouldn't be suprised if it's possible to do this with less code. It's a hard language to explain, since it's a 2D language where the code is wrapped around a cube. So the directions the instruction pointer take a hard to show in a description. I'll include a link to the online interpreter since it has a debug mode when you can see the way the code iterates through the cells.
But I'll try to explain it too...
```
[[email protected]](/cdn-cgi/l/email-protection)?i.o;o;.^ - code before it's wrapped on the cube...
    i          - (1) starts here, input a codepoint
     ?         - branch if top of stack, <0 "left", >0 "right"
  @            - "left" (true on EOF), halt program
             ^ - "right", set IP direction to "up"
     ?         - same branch, but coming from another direction
      i        - "right", input another codepoint
        o;     - output top of stack as char, pop it off stack
          o;   - repeat... code wraps back to (1)
```
The `.` characters are no-ops and are needed to place the other characters in the right position so they will wrap into place on the cube.
Here's a link to the online interpreter
<http://ethproductions.github.io/cubix/?code=Li5ALmk/aS5vO287Ll4=&input=MTIzNDU2Nzg=&speed=20>
[Answer]
# [C (clang)](http://clang.llvm.org/), ~~53~~ \$\cdots\$ ~~43~~ 42 bytes
```
f(*l,n){*l^=l[1]^(l[1]=*l);n&&f(l+2,n-2);}
```
[Try it online!](https://tio.run/##nVLtToMwFP2/p2hIRgorUbqPRBH9YXyKfRhgZRJLR4BEdOHVxQstoyNLNDZpS3vOPffcWyIn4oE4NE2MbU6EdbL5zudrd7vD7erb3PKEacaYzygRDrW8uklEidIgEdhCpwmC0V6UrChf3fUW@ejkEkrmZEGWZFV7lwwqGbfEJTDHqJBokXyxY4ylpHWjjrY6E6TjdIRTaxC1O9VCispoomxomVmVsahk@949BW8L8L8iy2ss2tfY1aAn6ymSMMgSLVjxo7cgt2Fl0TvLJd/YVC90U909w1waBOnnuaHi4mOOcGsnEXtWQditpz4f@q70uYa@nG88NJt17P7hztY5SMledfjW02EkFArvM4YHQ8oMGBFdHj1HO7IcaDE2psV0D@Xh5Kkt8t4w4EH5Otlag2g9GQch5xEZlndpOoSUacD5McILW2hoytIo@8Qh4eQSiOFOjGUYyJyf7lr5WVAUwHH/VbWM7TbTRAwKRb6PQti9P7cn/LU902IjgN//UG06PSLOGcOhuqgndfMdxTw4FI3z8QM "C (clang) ‚Äì Try It Online")
Inputs a pointer in an `int` array and the array's length (since pointers in C carry no length info).  
Swaps every two elements in place.
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 35 bytes
```
def f(m):*m[1:],_,m[::2]=*m,m[1::2]
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/PyU1TSFNI1fTSis32tAqVideJzfaysoo1lYrVwckAmT@T7SNNtQx0jHWMdEx1TGLtS4oyswr0UjUtE4DETAeF1iZgQ4Q41LyHwA "Python 3.8 (pre-release) ‚Äì Try It Online")
In-place. Essentially a golfed version of `m[1::2],m[::2]=m[::2],m[1::2]`
[Answer]
# [R](https://www.r-project.org/), 29 bytes
```
function(l)l[seq(!l)+2*1:0-1]
```
[Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/TyNHMye6OLVQQzFHU9tIy9DKQNcw9n@ahqGVmeZ/AA "R ‚Äì Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 26 bytes
```
->l{r=-1;l.map{l[1^r+=1]}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6nushW19A6Ry83saA6J9owrkjb1jC2tvZ/gUJadLShjpGOsY6JjqmOWWzsfwA "Ruby ‚Äì Try It Online")
[Answer]
# [J](http://jsoftware.com/), 9 bytes
```
[:,_2|.\]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/o6104o1q9GJi/2tyKXClJmfkK6QpGCoYKRgrmCiYKpj9BwA "J ‚Äì Try It Online")
[Answer]
# [4](https://github.com/urielieli/py-four), 22 bytes
```
3.72082072152152072094
```
[Try it online!](https://tio.run/##M/n/31jP3MjAwsjA3MjQFISADANLk///DY2MTUzNAA "4 ‚Äì Try It Online")
Readable + explanation:
```
3. 720 820 721 521 520 720 9 4
^^------------------------------ mandatory prefix
   ^^^-------------------------- initial input in cell 20
       ^^^-----------------^---- loop while cell 20 is nonzero
           ^^^------------------ input to cell 21
               ^^^-------------- output cell 21
                   ^^^---------- output cell 20
                       ^^^------ input to cell 20
                           ^---- end loop
                             ^-- exit
```
Corresponding [Quartic](https://esolangs.org/wiki/User:Conor_O%27Brien/Compilers/Quartic) program:
```
decl a, b
input a
loop a
  input b
  print b
  print a
  input a
end
```
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 43 41 bytes
```
{for(;++n<NF;n++)$n+=$(n+1)-($(n+1)=$n)}1
```
*Thanks for Dominic van Essen for 2 less bytes!*
[Try it online!](https://tio.run/##SyzP/v@/Oi2/SMNaWzvPxs/NOk9bW1MlT9tWRSNP21BTVwNC26rkadYa/v9vqGCkYKxgomCqYAYA "AWK ‚Äì Try It Online")
```
{
for(;++n<NF;n++)        Starts a loop though the numbers.
                        n has to start as 1, because $0 is the whole line.
$n+=$(n+1)-($(n+1)=$n)  Swap the numbers two by two.
                        Readable: a += b - (b = a)
}
1                       Prints the line.
```
[Answer]
# T-SQL, 32 bytes
Input is a table variable
```
SELECT a FROM @ ORDER BY b+b%2*2
```
**[Try it online](https://data.stackexchange.com/stackoverflow/query/1511250/swap-every-two-elements-in-a-list)**
[Answer]
# [CLC-INTERCAL](https://esolangs.org/wiki/CLC-INTERCAL), ~~95~~ 67 bytes.
Why does CLC-INTERCAL 1.-94.-2 lack `!1~.1'`? I could have golfed off one byte.
```
DOCOMEFROM#9(1)DOWRITEIN.1+.2DDOCOMEFROM'.1~.1'~#1(9)DOREADOUT.2+.1
```
[Copy and paste to try it online!](http://golf.shinh.org/check.rb)
## Usage
* Each item of list must be in `ONE` to `SIX FIVE FIVE THREE FIVE` (inclusive); `ZERO` for end of list.
	+ Given from STDIN, delimited with a LF.
* Outputs to STDOUT, as roman number.
## Try these inputs
```
ONE
TWO
ONE
TWO
ZERO
```
```
ONE
TWO
THREE
FOUR
FIVE
SIX
ZERO
```
[Answer]
# [Desmos](https://desmos.com/calculator), ~~39~~ 38 bytes
```
l=[1...L.length]
f(L)=L[l-1+2mod(l,2)]
```
[Try It On Desmos!](https://www.desmos.com/calculator/xmsjvpha3x)
[Try It On Desmos! - Prettified](https://www.desmos.com/calculator/qvcvjcjjpe)
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), ~~10~~ 9 bytes[SBCS](https://github.com/mlochbaum/BQN/blob/master/commentary/sbcs.bqn)
-1 byte thanks to [Razetime](https://codegolf.stackexchange.com/users/80214/razetime)!
```
‚•ä¬∑‚åΩÀò‚àò‚Äø2‚ä∏‚•ä
```
[Run online!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4qWKwrfijL3LmOKImOKAvzLiirjipYoKCkbCqCAoMOKAvzHigL8w4oC/MSnigL8oMSvihpU2KQ==)
`‚àò‚Äø2‚•äùï©` Reshape the input into a matrix with 2 columns and and the necessary number of rows.  
`‚åΩÀò` Reverse horizontally (Swap the 2 columns).  
`‚•ä` Flatten into a vector.
An alternative using the *Under* operator at 10 bytes:
```
‚åΩÀò‚åæ(‚àò‚Äø2‚ä∏‚•ä)
```
[Try it online!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4oy9y5jijL4o4oiY4oC/MuKKuOKliikKCkbCqCAoMOKAvzHigL8w4oC/MSnigL8oMSvihpU2KQ==)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jellylanguage), 4 bytes
```
s2UF
```
[Try It Online!](https://jht.hyper-neutrino.xyz/tio#WyIiLCJzMlVGIiwiIiwiIixbIjEsMiwzLDQsNSw2Il1d)
```
s2    Slices of length 2
  U   Reverse each
   F  Flatten
```
[Answer]
# [Perl 5](https://www.perl.org/) -p, 21 bytes
```
s/(\S+) (\S+)/$2 $1/g
```
[Try it online!](https://tio.run/##K0gtyjH9/79YXyMmWFtTAUzqqxgpqBjqp///b6hgpGCsYKJgqmDGZaBgqADE//ILSjLz84r/6xYAAA "Perl 5 ‚Äì Try It Online")
[Answer]
# APL+WIN, 17 bytes
Prompts for vector
```
,‚åΩ((.5√ó‚ç¥r),2)‚ç¥r‚Üê‚éï
```
[Try it online! Thanks to Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcQJanP5BlyPWooz3tv86jnr0aGnqmh6c/6t1SpKljpAmigfJAdf@BKrj@p3EZKhgpGCuYKJgqmHGlcRkoGCoAMRcXAA "APL (Dyalog Classic) ‚Äì Try It Online")
[Answer]
# [Zsh](https://www.zsh.org), 18 bytes
```
for a b;<<<$b<<<$a
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724qjhjwYKlpSVpuhab0vKLFBIVkqxtbGxUkkBEIkQCKr822lDHSMdYx0THVMcsFioIAA)
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform) with `Linq`, ~~32~~ 26 bytes
```
a=>a.Select((n,i)=>a[i^1])
```
[Try it online!](https://tio.run/##ZY/NSsRAEITPyVM0wUMGZgPr3yUml0VFURBy8BAijGMTGpKZdXriIiHPHmcTD7Ieq7r5qkrzRluH88BkWqi@2WOfx39V9kTm88Ta2a5D7ckazu7RoCOdx7pTzPDibOtUD2PMXnnScDcYfUPG1418uDVDj069d3h0yhL4oPZczKooVVbhkZmmRpIIuqa3bSPmPI5@QV@WPuBZkUnZu1CmbkC5lkWIiqIlAMjsBw8FGDzA6oywlXAu4ULCpYQrCdcwBWS0C9Vth9mrI49hIaZnyVgt3OzRhoxEJnLliQk2Jfw/Lt3T9UVMiQjYKZ7mHw "C# (.NET Core) ‚Äì Try It Online")
*-8 bytes thanks to m90's [witchcraft](https://chat.stackexchange.com/transcript/message/59572249#59572249)*
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 73 bytes
```
a=>{for(int i=0,d=0;i<a.Length;i++){d=a[i];a[i]=a[++i];a[i]=d;}return a;}
```
[Try it online!](https://tio.run/##ZY@9asQwEIRr@ykGk8LGOnP5bXRyE0gRLhC4IoVxIWzFWbiTDknOEYye3VHspEozDLPLN7ud23TGqnl0pAccvpxXJ552R@kcXq0ZrDxhSp2Xnjo8jbrbkfZNyxat4S7y7MQsRT29G5vHFCS2rBdbTjtZ7ZUe/AensiymXsiGWv4j0ZXln@95sMqPVkPyMPM0@S37NNTjRZLOnbfxuKaFtIMr4jlJstSD9Hn0ENDqgjWZcM1ww3DLcMdwz/CAEJHJo9HOHFX1ZsmrPWmVX2XTYeFWzyZ2ZCxjK68I2NT4P1xezdeVImRFxIY0zN8 "C# (.NET Core) ‚Äì Try It Online")
[Answer]
# [Add++](https://github.com/cairdcoinheringaahing/AddPlusPlus), 57 bytes
```
a:?
b:0
n:0
m:3
`b
Ea,Ib=n,,b:1,,x:i,+1,Ib=m,,b:0,,Oi,,Ox
```
[Try it online!](https://tio.run/##S0xJKSj4/z/Ryp4rycqAKw@Ic62MuRKSuFwTdTyTbPN0dJKsDHV0KqwydbQNQSK5IBEDHR3/TCCu@P//f7ShjpGOsY6JjqmOWSwA "Add++ ‚Äì Try It Online")
Input is the first argument.
]