[Question]
  [
In C++, there exists a [`a <=> b` three-way](https://stackoverflow.com/questions/47466358/what-is-the-spaceship-three-way-comparison-operator-in-c) [comparison operator](https://en.cppreference.com/w/cpp/language/operator_comparison) that, for numerical types, does the following:
* If `a < b`, then return a negative number.
* If `a = b`, then return a (mathematically speaking) sign-less number.
* If `a > b`, then return a positive number.
## The Challenge
Implement the **shortest** full program, function, method, or custom operator such that, when given two numbers of the same type `a` and `b`,
* If `a < b`, then return `-1`.
* If `a = b`, then return `0`.
* If `a > b`, then return `1`.
### Notes
* If you're writing in x86 assembly, [this question](https://codegolf.stackexchange.com/questions/259087/) may be of use to you.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins!
  
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), 2 bytes
```
×-
```
[Try it at BQN REPL](https://mlochbaum.github.io/BQN/try.html#code=R3RsdCDihpAgw5ctCkd0bHTCtMKoIOKfqCAz4oC/NiwgM+KAvzMsIDbigL8zIOKfqQ==)
```
×       # sign of
 -      # left arg minus right arg
```
---
# [BQN](https://mlochbaum.github.io/BQN/), 3 bytes
```
<->
```
[Try it at BQN REPL](https://mlochbaum.github.io/BQN/try.html#code=R3RsdCDihpAgPC0+Ckd0bHTCtMKoIOKfqCAz4oC/NiwgM+KAvzMsIDbigL8zIOKfqQ==)
This clearly isn't the shortest possible solution in [BQN](https://mlochbaum.github.io/BQN/) (see above), but it is particularly visually appealing due to its similarity to the C++/Perl/etc `<=>` operator.
```
<->     # 3-element train abc 
        # ( x abc y expands to: (x a y) b (x c y) )
<       # left arg < right arg
 -      # minus
  >     # left arg > right arg 
```
(a similar 'reverse-comparison' operator - [`>-<`](https://mlochbaum.github.io/BQN/try.html#code=THRndCDihpAgPi08Ckx0Z3TCtMKoIOKfqCAz4oC/NiwgM+KAvzMsIDbigL8zIOKfqQ==) is also possible and also [I think] looks nice)
[Answer]
# polyglot, 3 bytes
```
<=>
```
[Try it in Perl!](https://tio.run/##K0gtyjH9X1CUmVeiYPzfxtbuv5k1hKcUk6dkzQWVUQDKKBhjkTHDlPkPAA "Perl 5 – Try It Online")
<Insert [other languages](https://en.wikipedia.org/wiki/Three-way_comparison#High-level_languages) that already have the exact `<=>` operator here>
[Answer]
# [Python 2](https://docs.python.org/2/), 3 bytes
```
cmp
```
A built-in function that accepts \$a\$ and \$b\$ and returns \$a \lt = \gt b\$.
**[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPzm34H9BUWZeiUaahqmOgrmm5n8A "Python 2 – Try It Online")**
[Answer]
# JavaScript (ES6), 17 bytes
Expects `(a)(b)`.
```
a=>b=>(a>b)-(a<b)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1i7J1k4j0S5JU1cj0SZJ839yfl5xfk6qXk5@ukaahpGmhrGmJheGoBGGoDFY8D8A "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 22 bytes
```
lambda a,b:(a>b)-(a<b)
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSFRJ8lKI9EuSVNXI9EmSfN/QVFmXolGmoahjpGmJheCZ4jEMwLx/gMA "Python 3 – Try It Online")
Python 3 lacks the builtin `cmp`
-1 thanks to Dominic van Essen
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 2 bytes
```
-±
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCItwrEiLCIiLCI2XG44Il0=)
Takes input as b then a. Simply subtract the two numbers and get the sign of the result.
Alternatively a more fun looking, symbol only answer comes in at 17 bytes:
## [Vyxal](https://github.com/Vyxal/Vyxal), 17 bytes
```
-:::-<[::-$~-|:]/
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCItOjo6LTxbOjotJH4tfDpdLyIsIiIsIjEwXG4xMiJd)
Also takes b then a. This answer is purely just for fun, and could be made shorter by using numbers and letters (`-D0<[N|:]/`).
### Explained
```
-:::-<[::-$~-|:]/
-:                # Subtract the two numbers and push a copy
  ::-             # Push 0 to the stack by subtracting the top of the stack from itself
     <            # Is the original top of the stack < 0?
      [           # If so:
       ::         #   Duplicate the top of the stack twice. This could just be `D`, but that wouldn't be a symbol.
         -        #   Subtract those copies to get 0 again.
          $~-     #   Push the 0 under the top of the stack, and subtract without popping. The stack is now [0, a - b, -(a - b)]
             |    # Otherwise:
              :   #   Just duplicate the top of the stack
               ]  # this whole if statement was to make sure there was [a - b, abs(a - b)] as the stack
                / # Divide the top two stack items to get either -1, 0 or 1. negative/positive = -1, 0/0 = 0 and positive/positive = 1
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 14 bytes
```
Float::compare
```
[Try it online!](https://tio.run/##jY4xC8IwEIVn8ysytlCDxUFo1UVwc@ooDmdtSmrShORakNLfHmMoOOpNd@9973EdjLDuHk8vlNEWaRduNqCQ7KSVAQuobUnMcJeiprUE5@gFRE8nQsM4BAz6F92fpQY8Un7wcSuKOnqNL2NgKVpyoxYPqkJdUqEVfXu9UbCtSyeyql4OG8X0gMwEC2WfcLZ0JTnPcp6m5W9s@w@24dkucp8PZzL7Nw)
## [Java (JDK)](http://jdk.java.net/), 13 bytes
```
Long::compare
```
[Try it online!](https://tio.run/##jY49D4IwEIZn@ys6QoKNxMEE1MW1TozG4UQgRfqR9iAxhN9eCyFx1Jvu7n3uybUwwLZ9vryQRlukbZhZj6JjFy0NWEBtc2L6RydKWnbgHL2CUHQkNJRDwLD/okeuVXOm9cnPTZaVS1L5fMFXzXo1aPGkMsiiAq1Qze1OwTYuHsmmeDusJNM9MhMi7FRUs9UVpTxJeRznv7H9P9iOJ4eFmz@cyOQ/)
Only supports integers.
[Answer]
# Excel, 12 bytes
```
=SIGN(A1-B1)
```
where `A1` and `B1` contain *a* and *b* respectively.
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), 1.5 bytes (3 nibbles)
```
`$-
```
```
`$-         # full program
`$-$@       # with implicit args shown;
`$          # get sign of
   $        # arg1
  -         # minus
    @       # arg2
```
[![enter image description here](https://i.stack.imgur.com/2Reql.png)](https://i.stack.imgur.com/2Reql.png)
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 9 bytes
```
1&-_1^-%-
```
[Try it online!](https://ngn.codeberg.page/k#eJxLszJU0403jNNV1eXiSos2tDaIBVK6JtaGINrY2hhEGejBxCEsAFB/DI8=)
K lacks a sign builtin, which makes this a bit trickier.
`-%-` negative square root of a-b. This is negative if a>b, zero if a=b and `-0n` (negative null value) if a<b.  
`1^` Replace null with 1.  
If the input was restricted to integers, `0 1'` would calculate the sign, leading to `0 1'-` as a full solution.
[Answer]
# [Go](https://go.dev), ~~52~~ 51 bytes
```
func(a,b int)int{n:=1
for-1<n&&b-a<n{n--}
return-n}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=ZZDBisIwEIbZa55i9CAJZMSwFESsdw-Cl70uxGKkaKcSUxGKT-KlCPtQ7tNssqlY9ZAM8__z_RlyuW7K5tbb62yrN2sodE4sL_aldcO-KVyfHbUFA-lP5QyOb5-mooxruYKcnPCnpkmqmCktqikNBivUU6oJ8czs2lWWkM4R_f0Qgf1_gQuo2dJ6fEfccCUTITp9ItVL_-yjkviiJBLVmxJmWFbSwcFCn768BVW4UvgOlY8E3O2cuvYIHtjcK1ENyD1nNgPVpR9T2DIIinX2iTOyTXxaNUqyjfFW-2NNE-sf)
By @Kevin Cruijssen. Uses a `for` loop to get the return value rather than a chain of `if`s.
### Changelog
* -1 by @naffetS
### Old answer, 56 bytes
```
func(a,b int)int{n:=0
if a>b{n=1}
if a<b{n=-1}
return n}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=ZVC9asMwEKarnuLqSQKpWIMhlNh7h0KXrgXZREYkPgdFLgXjJ-liCn0o92kqRTZxkkG6u-9Ph75_6nacHo-q2qt6B40ySExzbK17SnTjEvKpLGjIfzunxWba6A4rqngJBh3zp8fnPCVGgyrKHnM5nPtt6IUf7M51FgGH6P97YCHg_Axl0JM36zMOSDWVPGNsNWdc3szXvJBc3CAZF_IOCRpStXhy8Kq-3j0FXbhy-AiVpgwW2uCaTuFie_FIRINlySkKkGv3RSVmjwBJVvtEDZ8Tr1aNEJ9jPDX_2DjG-g8)
Go doesn't have any sort of built-in `abs` like C, or default type methods like Java, so a function it is. Go also doesn't have ternary expressions, so the old-school "set and check" pattern is needed.
[Answer]
# [J](http://jsoftware.com/), 3 bytes
```
*@-
```
[Try it online!](https://tio.run/##y/qvpKegnqZga6WgrqCjYKBgBcS6egrOQT5u/7UcdP9rcqUmZ@QrGCukKZghmMYIpgGUqWcCEtcz/Q8A "J – Try It Online") The 3-byte solution `>-<` featured in a few other answers also works for the same byte count (greater-than minus less-than).
Works for any numeric type. Anonymous dyad.
## Explanation
```
*@-
*     sign
 @    of
  -   difference
```
[Answer]
# [Raku](https://raku.org/), 8 bytes
```
+(*cmp*)
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfW0MrObdAS/O/tUJxYqWCkkq8gq2dQnWaQo1KfK2SQlp@kYKNoYGCkZ2Ogo2RgqEBiAbygYz/AA "Perl 6 – Try It Online")
`cmp` is Raku's built-in smart comparison operator, and `*cmp*` is an anonymous function that passes its arguments to that operator.
Unfortunately for this challenge, `cmp` doesn't return -1, 1, or 0, but one of the enumerated values `Less`, `More`, or `Same`, so the prefix `+` operator converts those values into their integer values.
The non-golfy solution would be to just compose the two operators:
```
&prefix:<+> o &[cmp]
```
[Answer]
# [Kotlin](https://kotlinlang.org), 16 bytes
```
Float::compareTo
```
[Try it online!](https://tio.run/##y84vycnM@59WmqeQm5iZp6FZzVWWmKOQZqXglpOfWKKnAaY0FXTtFDzzShRsFf6DBayskvNzCxKLUkPy/1sXFGXmleTkaaRpGKbpKBilaWpyoQoZYgoZgIRq/wMA "Kotlin – Try It Online")
Annoyingly, longer than Java.
# [Kotlin](https://kotlinlang.org), 14 bytes
```
Int::compareTo
```
[Try it online!](https://tio.run/##y84vycnM@59WmqeQm5iZp6FZzVWWmKOQZqXgmVeipwEkNBV07UAcBVuF/0DKyio5P7cgsSg1JP@/dUFRZl5JTp5GmoahjoKRpiYXioAhuoABUKD2PwA "Kotlin – Try It Online")
Works only on ints (I edited this after seeing that Java got edited).
[Answer]
# [R](https://www.r-project.org), 15 bytes
```
\(a,b)sign(a-b)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhbrYzQSdZI0izPT8zQSdZM0IaJb0jQMdYw0uUCUIYgyAlIQqQULIDQA)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 2 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
.S
```
Builtin. Takes the inputs in the order \$b,a\$.
[Try it online.](https://tio.run/##yy9OTMpM/f9fL/j/fyMuUwA)
**Explanation:**
```
.S  # Compare the second (implicit) input-integer `a` with the first (implicit)
    # input-integer `b`, and push -1 if a<b; 0 if a==b; or 1 if a>b
    # (which is output implicitly as result)
```
[Answer]
## HP‑41C series, ~~9~~ 11 Bytes
`a` needs to be entered first, then `b`, so `a` is placed in the Y register and `b` in the X register.
```
01♦LBL⸆S     5 Bytes    global label requires 4 + m Bytes
02 SF 24     2 Bytes    ignore “out of range” errors, and instead
                        return ±9.999999999E99 as an approximation
03 −         1 Byte     X ≔ Y − X
04 X≠0?      1 Byte     if X = 0 then skip next line
05 SIGN      1 Byte     ↯ `SIGN` returns `1` for zero
06 RTN       1 Byte     `RTN` does not affect local label search
```
[Answer]
# [Golfscript](http://www.golfscript.com/golfscript/), 7 bytes
```
.~>\~<-
```
read from stdin
```
# explanation:
. # duplicate
~ # unpack
> # gt 
\ # store the result and get duplicated stdin again
~ # unpack
< # lt
- # gt-lt
```
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 2 bytes
```
cm
```
[Try it online!](https://tio.run/##SyotykktLixN/V9dkPo/Ofd/bXjOf0MFQwMDAy4QoWDIBeQBAA "Burlesque – Try It Online")
Built in compare.
[Answer]
# PIC16F88x Machine Code, 6 words (84 bits)
A function that expects `a` to be at address 0x70 in memory, and `b` to be in register W. Returns the result in register W.
The PIC16 uses 14-bit instruction words. Because the number of words is even, this function can be represented exactly in hex with no padding:
```
0bc1d03d001ff0dfff401
```
In mpasm syntax, that is:
```
    SUBWF 0x70,F   ; Subtract W from the value at 0x70. Leave the result at
                   ; 0x70.
    BTFSC STATUS,2 ; Check the zero flag (bit 2 of the STATUS register) and skip
                   ; the next instruction if it's not set.
    RETLW 0x00     ; Set the W register to 0 and return.
    BTFSC 0x70,7   ; Skip the next instruction if the MSb of the value at 0x70
                   ; is 0 (i.e. the result of subtraction is positive).
    RETLW 0xFF     ; Set the W register to 0xff (-1) and return.
    RETLW 0x01     ; Set the W register to 1 and return.
```
Bit for bit, this is encoded as:
```
00 0010 1111 0000
00 0010           SUBWF
         111 0000       0x70
        1                    F
01 1101 0000 0011
01 11             BTFSC
         000 0011       STATUS
     01 0                      2
11 0100 0000 0000
11 01             RETLW
        0000 0000       0x00
     00                      (ignored)
01 1111 1111 0000
01 11             BTFSC
         111 0000       0x70
     11 1                    7
11 0111 1111 1111
11 01             RETLW
        1111 1111       0xff
     11                      (ignored)
11 0100 0000 0001
11 01             RETLW
        0000 0001       0x01
     00                      (ignored)
```
The PIC16F88x family of microcontrollers have four memory banks of 128 bytes each. (These are actually bytes this time, and not 14-bit words.) Which one is used depends on the value of the STATUS register. However, addresses 0x70 through 0x7f are the same on all banks, so by placing the operands there the function doesn't have to change banks to access them. I'm not aware of any standard calling convention as far as argument location goes, but the return value being in register W is standard (hence the existence of the `RETLW` instruction).
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 5 bytes
```
-/<?,
```
[Try it online!](https://ngn.codeberg.page/k#eJxNikEOgjAQRfc9xSxcaOJQRFlITbyEO0JCxUEI0GJbIsTo2a1EE5P5mf/yX5kgPxzXjJ2SxyKdXiYpIYBR5LoRy7yUdStGMQmzyp7eSQFgAxAK/7IZceerAPwibP35NZwxDP5l/OFHZpxVzvU24bzQF7rqtgysk0VDY1FJdaWg0B2/DWRdrZXlUbyP4pjXXd9SR8qhq8jHEOFdTujlXpraaoW6JyOdNui7GrozGcvecr9DqA==)
* `,` concatenate the inputs
* `<?` grade-up the distinct-ified result from above; if the first value is smaller than the second, the result will be `0 1`; if larger, `1 0`, if the same, `,0`
* `-/` run a minus-reduce and (implicitly) return
An alternative version that takes the input as a list of two numbers is `-/<?:`.
[Answer]
## Pascal, 55 Bytes
```
function f(a,b:real):real;begin f:=ord(a>b)-ord(a<b)end
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 29 bytes
```
\d+
$*
(1*) \1
0
1+0
1
01+
-1
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wPyZFm0tFi0vDUEtTIcaQy4DLUBuIuQwMtbl0Df//N1Yw5zJVMOUyVzAGAA "Retina 0.8.2 – Try It Online") Link includes test cases. Only works on non-negative integers. Explanation:
```
\d+
$*
```
Convert to unary.
```
(1*) \1
0
```
Try to subtract; this will leave `0` if `a = b`.
```
1+0
1
```
If `a > b` then replace the result with `1`.
```
01+
-1
```
If `a < b` then replace the result with `-1`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 12 bytes
```
ＮθＮηＩ⁻›θη‹θη
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98zr6C0xK80Nym1SKNQ05oLmZ8B5AcUZeaVaDgnFpdo@GbmlRZruBelJpaAFOsoZGjqKPikFhdD2EBg/f@/sYL5f92yHAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation: Port of @Arnauld's JavaScript answer.
Alternative approach, also 12 bytes:
```
≔⁻ＮＮθＩ÷θ∨↔θ¹
```
[Try it online!](https://tio.run/##S85ILErOT8z5/9@xuDgzPU/DNzOvtFjDM6@gtMSvNDcptUhDU0cBhQvkF2pacwUUZeaVaDgnFpcAVZe4ZJZlpqRqFOoo@BdpOCYV5@eUlgC5QLWGmkBg/f@/sYL5f92yHAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation: Divides the difference between the numbers by the absolute value of the difference, or `1` if that's zero.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 2 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
,σ
```
[Try it online.](https://tio.run/##y00syUjPz0n7/1/nfPP//0YKplymYGwEAA)
**Explanation:**
```
,  # Subtract the second (implicit) input by the first (implicit) input: b-a
 σ # Get the sign of that (-1 if <0; 0 if ==0; 1 if >0)
   # (after which the entire stack is output implicitly as result)
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 22 bytes
This is practically @TobySpeight's answer now since he changed the entire algorithm.
```
f(a,b){a=(a>b)-(a<b);}
```
[Try it online!](https://tio.run/##PY0xCoRADEV7T/ERlAQypWzh6klskhHFYodl1048@xhFTJEi/738GOYYc55IxXjTjrQ3DqRv43bPH10ScbEVuGdJK1Rg7XP5R00TldWIaiwFtae1u0/@/blzAeIEQu97SE6ebwRnMYxd2HOD1wE "C (gcc) – Try It Online")
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 4 bytes
```
aCMb
```
There's a built-in operator for that. (Fun fact: in my original designs for Pip, this operator was `<=>`, until I realized that having a 3-character operator in a golfing language was silly.)
[Attempt This Online!](https://ato.pxeger.com/run?1=m724ILNgwYKlpSVpuhZLEp19kyBMqMjKaGMdBWM9Q5NYqAAA)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 3 bytes
```
._-
```
[Try it online!](https://tio.run/##K6gsyfj/Xy9e10jB5P9/AA)
Defines a function which takes two inputs b, a.
### Explanation
```
  -    # subtract the second argument from the first
._     # take the sign
```
[Answer]
# [Julia 1.0](http://julialang.org/), ~~13~~ 3 bytes
```
cmp
```
[Try it online!](https://tio.run/##yyrNyUw0rPifZvs/Obfgv0NxRn65QpqeRrSJjqmOWaxOtCmQNo3V/A8A "Julia 1.0 – Try It Online")
-10 bytes thanks to MarcMush: use `cmp`
## Alternate solution, 13 bytes
```
a%b=sign(a-b)
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/P1E1ybY4Mz1PI1E3SfO/Q3FGfrlCtImOqY5ZrIKeqkK0KZBpGvsfAA "Julia 1.0 – Try It Online")
## Alternate solution (15 bytes)
```
a%b=(a>b)-(a<b)
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/P1E1yVYj0S5JU1cj0SZJ879DcUZ@uUK0iY6pjlmsgp6qQrQpkGka@x8A "Julia 1.0 – Try It Online")
Some operators have lower precedence than `<` and `>`. Redefining one of them as `-` removes the need for parentheses but doesn't save bytes overall:
```
~=-
a%b=a>b~a<b
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/v85WlytRNck20S6pLtEm6b9DcUZ@uUK0iY6pjlmsgp6qQrQpkGka@x8A "Julia 1.0 – Try It Online")
[Answer]
# [Piet](https://www.dangermouse.net/esoteric/piet.html) + [ascii-piet](https://github.com/dloscutoff/ascii-piet), 21 bytes (4×7=28 codels)
```
vekabrA krbtkFbks?Tbb
```
[Try Piet online!](https://piet.bubbler.one/#eJxVisEKwjAQRH9F5jyBbFq0ya8kOUiNUKhpIXoS_92NXnQZ2Nn39ol5uxSEGIVyoqccKSOd7swoXonrwHY1dDRqGyiTItXiv6zH_yZnopUdAcYYEOty0y5WR6_SZoTreW2FWOr-uH_cwdlU9T1V99_F4vUGIvQocg)
![](https://piet.bubbler.one/api.svg?4,7,1,17,9,16,14,2,16,19,9,2,14,0,9,13,14,9,3,18,0,19,19,14,14,19,19,19,19,19)
Just a minor variation from [my answer to "output the sign"](https://codegolf.stackexchange.com/a/246527/78410). Takes two numbers and subtracts instead of taking just one number, and then the rest follows the same logic.
```
A1->A4
inN inN -    [a-b] Take two numbers and subtract
A4->A7->B7->B5
dup 1 ! > !  [a-b a-b<=0]
CC+          [a-b] Continue on row B if a-b<=0, shift to row C otherwise
B5->B2
! 1 -        [(a-b==0)-1] -1 if a-b!=0 (which implies a-b<0), 0 otherwise
C5->C2
1            [a-b 1] Ignore the previous number and push 1
C2->C1
outN         Print the top number and exit
```
]