[Question]
  [
**This question already has answers here**:
 
 
[The Versatile Integer Printer](/questions/65641/the-versatile-integer-printer)
 (41 answers)
 
Closed 6 years ago.
> 
> **Note:** This challenge has been moved to [Polyglot the (non constant) OEIS!](https://codegolf.stackexchange.com/q/139036/61563) to avoid closure.
> 
> 
> 
## Introduction
We all know and love the *on-line encyclopedia of integer sequences* ([OEIS](https://oeis.org/)). So what if we made an *off-line* version? Well, that would be kinda too easy, wouldn't it and how would you select a sequence with our standard interface!? No. We need an easier solution to this. A polyglot!
## Input
Your input will be a non-negative integer `n`.
## Output
Your output will either be
* The `n`-th entry of an OEIS sequence OR
* The first `n` entries of an OEIS sequence.
You may take the index to be 1-based or 0-based as you prefer.
## Uhm, so where is the Challenge?
You have to polyglot the above functionality. That is if you support languages A, B and C all must implement different OEIS sequences. The choice of sequence is not limited except that you need different ones for all languages.
That is, if you run the provided program in language A, then sequence X shall be generated, if you run the provided program in language B, then sequence Y shall be generated (with X!=Y) and if you run the provided program in language C, then sequence Z shall be generated (with X!=Z && Y!=Z).
## Who wins?
The answer with the most sequence/language pairs wins. First tie-breaker is code-size (in bytes) with lower being better. Second tie-breaker is submission time with earlier being better.
## Any final Words / Rules?
* You must declare which language will generate which sequence.
* [Standard I/O rules apply.](https://codegolf.meta.stackexchange.com/q/2447/55329)
* If different encodings are used between languages, both programs must use the same byte-sequence.
* Language (Python 2/3) revisions *do* count as different languages. Different implementations of a language (such as Browser JS vs Node.js) also count as different languages.
* [Standard loopholes apply.](https://codegolf.meta.stackexchange.com/q/1061/55329)
  
[Answer]
# 26 languages: C, C++, Cubically, rk, what, Bash, Morse, Ook!, str, Charcoal, Commercial, S.I.L.O.S, memescript, Forked, TRANSCRIPT, Braingolf, Fission, Arcyou, Beam, Beatnik, Cood, COW, Emoji, ><>, Set, NTFJ
Over 1000 bytes >.< but I'm gonna go for the most languages.
Hit `Page Down` about 10 times if you don't want a description of all the languages.
```
#\
//ha kkkkkkkkkk ja ha kkkkkkkkkkd ja skd  I7Oq2_
#include<stdio.h>//$+77%6& ..... rk:start print: "11" rk:end  ?!!!!!!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!??!????!        Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. âŽš8Â» ##########################################
 /*
echo -n 3;exit
Hey, waiter!
I want 25 of this.
How much is it?
The bill, please.
foo now 9 dollars off!
foo has been selling out worldwide!
a = 10
printInt a
filler what the frick frack thumbtack diddily dack crack pack quarterback frick frack (p 22)
>F9+%&'L+:+:H
Ju is here.
>Ju, 32
>X Ju
 set ! 50
 set ! 56
oom MoO OOM  ðŸ’¬26ðŸ’¬âž¡ #####/
*/main(int a){getchar();printf("%d",sizeof(' '));}/* R"21"
 >2n7n; */
```
This outputs:
* [A010709](https://oeis.org/A010709) in [C](https://tio.run/##7ZNBbhMxFIb3PsU/U9JMmjTTTNSEJjDZoSSiioRYsKiEnLEnNpnYqe3RUBBXYMGSBYg9N2DHUXoCbhA8I2jFDRDiyfr8@9nPfk/Wy043WXY4HF2ROBYU2zvDK4o/HKz2WD8txqvr5CU5kiorSsYfWcek7os0jh90x@PW6Bj92mC2E@uocdgbqdwE4WAQ1k6u2CxobDb7C4cHVnrbr3GvZnfqP/5Z/Pru2/cfH37/RhCfEJ4JjVOF4ZS/lo7M@U0PFZWOm4AsvFIOyTl0Diek7ZO5rrArMwFpId2MPBcca1kUPewLTi3vk1xrKH/qAkwXBTXWB@dB4xbUYs25guVFIdUGunSotClYJRkPCMVjDM5I000L/zAlub@aG1SCOp8AR25ktvWknk6Uu7WrFZOMyeIGrF5kzea@xnXpm5ObNW1i7iOjPZKkQ9InF93Wcftpd9KdzMmyrGsS3Pga0mXZwzAh6QssS2K5Q4Dzs99iRLTe4VKvsFpdAj8@f/iajGrefvpCTuIdlSqSdfqdtxvuMkFN1Jk2ReVR2GJhz8o3XOdRG@1OZ/oujp@FySC8IkgTNVbTw2H4Ew) `a(n) = 4`
* [A000012](https://oeis.org/A000012) in [C++](https://tio.run/##7ZNBbhMxFIb3PsWfKWkmTZppJmpCE8jsUBJRjYRYsKiEnLEnNpnYU9ujUBBXYMGSBYg9N2DHUXoCbhA8I2jFDRDiyfr8@9nPfk/Wy8rydJNlh8PRFYkiQbG9M7yi@MPBao/103KSXscvyZFUWVEx/sg6JvVAzKPoQW8yaY@PMagNZju1jhqH0kjlpgiGw6B2csWSVmNJ8hcOD6R6O6hxr5I79R//LH599@37jw@/fyOITgjPhMapwmjGX0tHFvymjz2VjpsWWXqlHOJz6BxOSDsgC73HrsoEpIV0CXkuONayKPooC04tH5Bcayh/6gJMFwU11gfnrcYtqMWacwXLi0KqDXTlsNemYHvJeItQPMbwjDTdtPQPU5L7q7nBXlDnE@DIjcy2ntTTiWq3drVikjFZ3IDVi6zZLGtcV745uVnTJuY@MiwRx10yf3LRax93nvamvemCrKq6JsGNr2G@qvoYxWT@AquKWO7QwvnZbzEmWu9wqVOk6SXw4/OHr/G45u2nL@Qk2lGpQlmn33274S4T1ITdWVNUHgZtFvStfMN1HnbQ6XZn76LoWRAPgyuCeawmanY4jH4C) `a(n) = 1`
* [A005843](http://oeis.org/A005843) in [Cubically](https://tio.run/##7ZNBbhMxFIb3PsWfKWkyTcg0EzWhCSQ7lERUIyEWLCohZ@ypTRw7tT1KA@IKLFiyALHnBuw4Sk/ADYJnBK24AUI8WZ9/P/vZ78l6ebmSOVVqfzgcXZIkERTrO8Nrij8crPK4MC1G2XX6ihxJnauS8cfOM2l6YpokDzqjUXN4jF5lsOux89R6bK3Ufoyo348qJ9ds1qhtNvsLRwAys@5VuFezO/Uf/yx@ffft@4@Pvn8jSE4Iz4XBQ43BhN9IT@Z838WOSs9tgyyC0h7pGUwBL6TrkbnZYVPmAtJB@hl5IThWUqkutopTx3ukMAY6nDoHM0pR60Jw0ajdgjqsONdwXCmpr2BKj52xiu0k4w1C8QT9U1J30yI8TEkRruYWO0F9SICjsDJfB9JAL8rNyleKScak2oNVi7ze3Fa4LkNzcruidcx9ZHuLNI3J9Ol5p3ncetYZd8ZzsiyrmgS3oYbpsuxikJLpSyxL4rhHA2env8WQGLPBhcmQZRfAj88fvqbDirefvpCTZEOlbssq/fjtFfe5oLYdT@qiinbUZFHXyTfcFO0WWnE8eZckz6O0H10STFM90pPDYfAT) `a(n) = 2n`
* [A010850](http://oeis.org/A010850) in [rk](https://tio.run/##7ZNBbhMxFIb3PsU/U9IkTcg0EzWhCSQ7lERUIyEWLCohZ@ypzUzs1PZoWhBX6KJLFiD23IAdR@kJuEHwjKAVN0CIJ@vz72c/@z1Zz@T7/cE5iSJBkd8b3lL84WC1x/ppNUku4zfkQKq0KBl/ah2TeiDmUfSoN5m0xocY1AaTT62jxmFnpHJThMNhWDu5YougscXiLxweSHQ@qPGgFvfqP/5Z/Pruu5uPT75/I4iOCE@FxmOF0YxfSUeW/LqPikrHTUBWXimH@AQ6gxPSDshSV9iWqYC0kG5BXgmOjSyKPnYFp5YPSKY1lD91CqaLghrrg7OgcQtqseFcwfKikOoCunSotClYJRkPCMUzDI9J000r/zAlmb@aG1SCOp8AR2ZkmntSTyfK7cbViknGZHENVi/SZnNX47L0zcnNhjYxD5GdHeK4S@bPT3utw/aL3rQ3XZJ1WdckuPE1zNdlH6OYzF9jXRLLHQKcHP8WY6L1Fmc6QZKcAT8@336NxzXvPn0hR9GWStWRdfrd9xfcpYKaTnfWFJV1whYL@1a@4zrrtNHudmcfouhlGA/Dc4J5rCZqtt@PfgI) `a(n) = 11`
* [A007395](http://oeis.org/A007395) in [what](https://github.com/gimmetehcodez/what) `a(n) = 2`
* [A010701](http://oeis.org/A010701) in [Bash](https://tio.run/##7ZNBbhMxFIb3PsU/U9IkTcg0EzWhCSQ7lERUIyEWLCohz9hTm0zs1PZoWhBX6KJLFiD23IAdR@kJuEHwjKAVN0CIJ@vz72c/@z1ZL6VW7PcH5ySKBMXm3vCW4g8Hqz3WT6tJchm/IQdSZUXJ@FPrmNQDMY@iR73JpDU@xKA2mM3UOmocdkYqN0U4HIa1kyu2CBpbLP7C4YFEbwY1HtTiXv3HP4tf33138/HJ928E0RHhmdB4rDCa8SvpyJJf91FR6bgJyMor5RCfQOdwQtoBWeoK2zITkBbSLcgrwZHKouhjV3Bq@YDkWkP5U6dguiiosT44Dxq3oBYp5wqWF4VUF9ClQ6VNwSrJeEAonmF4TJpuWvmHKcn91dygEtT5BDhyI7ONJ/V0otymrlZMMiaLa7B6kTWbuxqXpW9OblLaxDxEdnaI4y6ZPz/ttQ7bL3rT3nRJ1mVdk@DG1zBfl32MYjJ/jXVJLHcIcHL8W4yJ1luc6QRJcgb8@Hz7NR7XvPv0hRxFWypVR9bpd99fcJcJajrdWVNU3glbLOxb@Y7rvNNGu9udfYiil2E8DM8J5rGaqNl@P/oJ) `a(n) = 3`
* [A010716](http://oeis.org/A010716) in [Morse](https://github.com/aaronryank/minproj/blob/master/morse/morse.c) `a(n) = 5`
* [A000004](http://oeis.org/A000004) in [Ook!](https://github.com/gimmetehcodez/ook) `a(n) = 0`
* [A010727](http://oeis.org/A010727) in [str](https://tio.run/##7ZNBbhMxFIb3PsU/U9IkTcg0UzWhCWR2KImoRkIsWFRCzthTm0zs1PYoLYgrsGDJAsSeG7DjKD0BNwj2CFpxA4R4sj7/fvaz35P1rDP7/cEFSRJBsb4zvKb4w8GCx/ppMc6v0lfkQKqiqhl/bB2TeiBmSfKgNx63RocYBINZT6yjxmFrpHITxMNhHJxcsSxqLMv@wuGBXK8HAfcqu1P/8c/i13ffvv/46Ps3guSI8EJoPFQ4mfJr6cic3/Sxo9JxE5GFV8ohPYUu4YS0AzLXO2zqQkBaSJeRF4JjJauqj23FqeUDUmoN5U@dgemqosb64DJq3IJarDhXsLyqpLqErh122lRsJxmPCMUTDI9J000L/zAlpb@aG@wEdT4BjtLIYu1JPZ2oNysXFJOMyeoGLCyKZnMbcFX75uRmRZuY@8jOFmnaJbOnZ73WYftZb9KbzMmyDjUJbnwNs2Xdx0lKZi@xrInlDhFOj3@LEdF6g3OdI8/PgR@fP3xNR4G3n76Qo2RDperIkH737SV3haCm0502RZWduMXivpVvuC47bbS73em7JHkep8P4gmCWqrGa7vc/AQ) `a(n) = 7`
* [A010731](http://oeis.org/A010731) in [Charcoal](https://tio.run/##7ZRBbhMxFIb3PsWfKWlmmpBppmpCE8jsUBJRRUIsWFRCzthTmzh2anuUFsQVWLBkAWLPDdhxlJ6AGwTPCFpxA4R4sj7/fvaz35NlF4LawlC13x9ckDQVFOs7w2uKPxys9rjQzUfLq@wVOZC6UBXjj51n0vTFNE0fdEej9vAQ/dpg12PnqfXYWqn9GNFgENVOrlneaizP/8IWgKVZ92vcq/xO/cc/i1/Xffv@46Pv3wjSI8ILYfBQ42TCr6UnM37Tw45Kz22LzIPSHtkpTAkvpOuTmdlhUxUC0kH6nLwQHCupVA9bxanjfVIaAx1WnYEZpah1IbhsNW5BHVacaziulNSXMJXHzljFdpLxFqF4gsExaV7TPBxMSRm25hY7QX1IgKO0slgH0kAvqs3K14pJxqS6AasHRTO5rXFVhcfJ7Yo2MfeR8RZZlpDp07Nu@7DzrDvujmdkUdU1CW5DDdNF1cNJRqYvsaiI4x4tnB7/FkNizAbnZonl8hz48fnD12xY8/bTF3KUbqjUsazTT95ecl@ELyhOJk1RZRy1WdRz8g03ZdxBJ0km79L0eZQNoguCaaZHerLf/wQ) `a(n) = 8`
* [A010734](http://oeis.org/A010734) in [Commercial](https://tio.run/##7ZNBbhMxFIb3PsWfKWkyTcg0UzWhCSQ7lERUIyEWLCohZ@ypTTx2anuUFsQVWLBkAWLPDdhxlJ6AGwTPCFpxA4R4sj7/fvaz35P1clOW3OaSqv3@4IIkiaDY3BleU/zhYLXHhWk5zq7SV@RA6lxVjD92nkkzELMkedAbj9ujQwxqg91MnKfWY2ul9hNEw2FUO7lm81Zj8/lfOAKQmc2gxr2a36n/@Gfx67tv33989P0bQXJEeC4MHmqcTPm19GTBb/rYUem5bZFlUNojPYUp4IV0A7IwO5RVLiAdpJ@TF4JjLZXqY6s4dXxACmOgw6kzMKMUtS4EF63GLajDmnMNx5WS@hKm8tgZq9hOMt4iFE8wPCZNNy3Dw5QU4WpusRPUhwQ4CivzTSAN9KIq175WTDIm1Q1YvcibzW2Nqyo0J7dr2sTcR3a3SNOYzJ6e9dqHnWe9SW@yIKuqrklwG2qYrao@TlIye4lVRRz3aOH0@LcYEWNKnJsMWXYO/Pj84Ws6qnn76Qs5SkoqdVfW6cdvL7nPBbXdeNoUVXSjNov6Tr7hpuh20Inj6bskeR6lw@iCYJbqsZ7u9z8B) `a(n) = 9`
* [A010692](http://oeis.org/A010692) in [S.I.L.O.S](https://tio.run/##7ZNBbhMxFIb3PsWfKWmSJsw0UzWhCWR2KImoIiEWLCohZ@ypTRw7tT2aFsQVWLBkAWLPDdhxlJ6AGwTPCFpxA4R4sj7/fvaz35P1nFTG7fcHFyRJBMXmzvCa4g8Hqz0uTIvx6ip9RQ6kzlXJ@GPnmTSxmCXJg/543B4dIq4NdjNxnlqPnZXaTxANh1Ht5Jplrcay7C8cAViZTVzjXmV36j/@Wfz67tv3Hx99/0aQHBGeC4OHGidTfi09mfObASoqPbctsghKe6SnMAW8kC4mc1NhW@YC0kH6jLwQHGup1AA7xanjMSmMgQ6nzsCMUtS6EFy0GregDmvONRxXSupLmNKjMlaxSjLeIhRPMDwmTTctwsOUFOFqblEJ6kMCHIWV@SaQBnpRbte@VkwyJtUNWL3Im81djasyNCe3a9rE3Ed2d0jTHpk9Peu3DzvP@pP@ZE6WZV2T4DbUMFuWA5ykZPYSy5I47tHC6fFvMSLGbHFuVlitzoEfnz98TUc1bz99IUfJlkrdlXX6vbeX3OeC2m5v2hRVdKM2iwZOvuGm6HbQ6fWm75LkeZQOowuCWarHerrf/wQ) `a(n) = 10`
* [A010855](http://oeis.org/A010855) in [memescript 1.0](https://github.com/aaronryank/memescript-1.0/) `a(n) = 16`
* [A010863](http://oeis.org/A010863) in [Forked](//git.io/Forked) `a(n) = 24`
* [A010871](http://oeis.org/A010871) in [TRANSCRIPT](https://tio.run/##7ZNBbhMxFIb3PsU/U9IkTcg0UzWhCczsUBJRjYRYsKiEnLGnNpnYU9ujtCCuwIIlCxB7bsCOo/QE3CB4RtCKGyDEk/X597Of/Z6s5wxVNjeycvv9wQWJIkGxuTO8pvjDwRqP9dNyml3Fr8iBVHlZM/7YOib1SCRR9GAwnXYmhxg1BrOZWUeNQ2WkcjOE43HYOLliadBamv6FwwOZ3owa3Kv0Tv3HP4tf3337/uOj798IoiPCc6HxUOFkzq@lIwt@M8SOSsdNQJZeKYf4FLqAE9KOyELvsK1zAWkhXUpeCI61LMshqpJTy0ek0BrKnzoD02VJjfXBRdC6BbVYc65geVlKdQldO@y0KdlOMh4QiicYH5O2m5b@YUoKfzU32AnqfAIchZH5xpN6OlFv165RTDImyxuwZpG3m1WDq9o3Jzdr2sbcR/YqxHGfJE/PBp3D7rPBbDBbkFXd1CS48TUkq3qIk5gkL7GqieUOAU6Pf4sJ0XqLc50hy86BH58/fI0nDW8/fSFH0ZZK1ZNN@v23l9zlgppef94WVfTCDguHVr7huuh10e335@@i6HkYj8MLgiRWUzXf738C) `a(n) = 32`
* [A010859](http://oeis.org/A010859) in [Braingolf](https://tio.run/##7ZRBbhMxFIb3PsWfKWmSJsw0UzWhCczsUBJRRUIsWFRCnrGnNnHGqe3RtCCuwIIlCxB7bsCOo/QE3CB4RtCKGyDEk/X597Of7SfrOTNUlpdaFfv9wQWJIkGxuTO8pvjDwRqP9d1yur6KX5EDWeaqYvyxdUzqUCRR9GA4nXYnhwgbg9nMrKPGYWdk6WYIxuOgcfKSpZ3W0vQvbB5Y603Y4F6ld@o//ln8eu7b9x8fff9GEB0RnguNhyVO5vxaOrLgNyPUVDpuOmTpVekQn0IXcELakCx0jW2VC0gL6VLyQnBkUqkRdopTy0NSaI3SrzoD00pRY31w0WndglpknJewXClfmNCVQ62NYrVkvEMonmB8TNpqWvqDKSn81tygFtT5C3AURuYbT@rpRLXNXKOYZEyqG7BmkLeTuwZXlS9ObjLaxtxH9neI4wFJnp4Nu4e9Z8PZcLYgq6rJSXDjc0hW1QgnMUleYlURyx06OD3@LSZE6y3O9Rrr9Tnw4/OHr/Gk4e2nL@Qo2vo/py@b6w/eXnKXC2r6g3mbVNEPuiwYWfmG66LfQ28wmL@LoudBPA4uCJK4nJbz/f4n) `a(n) = 20`
* [A010860](http://oeis.org/A010860) in [Fission](https://tio.run/##7ZNfTsJAEMbf9xTTItACthYSEdD2zQReSHzywcQs3V12w7ILu9vgn3gFD@BVfPMoXqS2jXIGY/wy@eWbmUwyyWSYsFZoVZatOxTH8/FyP7xHLaFyWRB6aR0ROuJpHJ/0x@P2eQeiWmA2U@uwcbAzQrkp@Eni10WqSOY1yrJfGBXgR0u9iWp4R5cd3T/@LL7P/fn6dvHxjiDuIZpzDacKRjP6IBxiWoPSB5gA0VJiY0Ez5jVlji2sKFVgqZRCrUEXDg7aSHIQhHoIwxUkZ6j5iblygFEaXU/67Q5aFCAscGpohNJFMYDREKW3sCgQE1JSAweOHThOgRmRbyriio4X25WrHRGECPkIpE7yprmrsS@qJ6RmhZuZ4yTqxVssVBA@r6nLOTZBOGu2YoHfJv7AiieqWdCFbhjOXuL4xh8mfll@AQ) `a(n) = 21`
* [A010861](http://oeis.org/A010861) in [Arcyou](https://tio.run/##7ZNRSsNAEIbf9xST1LZJWxOTgrWtJm9C@1LwyQdBttlNd@l2t93sUqt4BQ/gVXzzKF4kJkHrFUT8GT7@mWFgYBiss4OyZdm6Q2E4Gy128T1qcZkJS@hlYQhXAUvC8KQ/GrXPOxDUAr2eFAZrA1vNpZmAG0VuXaSSpE6jNP2FUQG@tVDroIZzdOnR/ePP4uvcHy@vF@9vCMIeohlTcCphOKUP3KBcKZBqD2MgSgisC1B57jRlhgtYUiqhoEJwuQJlDeyVFmTPCXUQhiuIzlDzEzNpAKMkuB732x00t8ALYFTTACVzO4BhjJJbmFuUcyGohj3DBgyjkGuerSviiobZzdLUjnBCuDgAqZOsaW5r7Gz1hFQvcTPzM@ltIY591As3mEsP@08rajKGtedPm@1yz20Td1DwR6pyrwtd358@h@GNG0duWX4C) `a(n) = 22`
* [A010862](http://oeis.org/A010862) in [Beam](https://tio.run/##7ZPBbhMxEIbvfoo/W9IkTcg2WzWhCWRvKImoIiEOHCohZz1bm2zs1PYqLYhX4MCRA4g7b8CNR@kT8AbBu4JWvAFCjKzPv8cee0bWrIhv9vuDCxbHkmN9Z3jN8YdDVB4XpvloeZW8YgdKZ0Up6LHzQpm@nMbxg@5o1Bweol8Z7HrsPLceW6u0HyMaDKLKSVqkjdrS9C8cAViadb/CvUrv1H/8s/j13bfvPz76/o0hPmKUSYOHGicTulaeTZ@edZuHrWfdcXc8YzO66WHHlSfbYPOgtEdyCpPDS@X6bGZ22JSZhHJQPmUvJGGliqKHbUHcUZ/lxkCHU2cQpii4dSE4b9RuyR1WRBqOikLpS5jSY2dsIXZKUINxPMHgmNW9NQ8Pc5aHq8liJ7kPCRByq7J1IA/0stysfKWEEkIVNxDVIqs3txWuytCqZFe8jrmPbG@RJB22KKsqJNmQ9XRR9nCSsOlLLErmyKOB0@PfYsiM2eDcLLFcngM/Pn/4mgwr3n76wo7iDVe6raqEO28vyWeS23ZnUpeRt6OmiHpOvSGTt1todTqTd3H8PEoG0QXDNNEjPdnvfwI) `a(n) = 23`
* [A010863](http://oeis.org/A010863) in [Beatnik](https://tio.run/##7ZPfSsMwFMbv8xRnndvaVRvXgXOdbnfihjDwygtBsiZdYrNkS1PmH3wFH8BX8c5H8UVqW2TDNxDxI/zy5TscOBDOghGrRFoUzVuEMSeQ7gT3BH4EtEqy8poO5pvwDjWFimVO2VlmqdABH2N84A8GrZM2BJXApFFmibGwNkLZCJxez6lCpuikUWsy@YWnBMx1GlTYu8nO/ePP4vu7P1/fTj/eEeAuYjHXcKSgP2IPwqJEa1B6C0OgWkpiMtBJ0qhjTjJYMKYgY1IKtQSdW9hqI@lWUNZABM6hd4zqXZgqCwSNg4uh32p3rvzIjy7RLAeRAWeGBWg8yw@hH6LxDcxylAgpmYEtJxYsZ5AYEaclSUnL89XCVo4KSoV8BFo94rq4rrDJyx1kZkHqnn2nu4Yw9FAXr4hQrqhG8p6XzMacGNcb1YMmrtOizmEmnphO3A50PG/0gvG1E/acouh/AQ) `a(n) = 24`
* [A010864](http://oeis.org/A010864) in [Cood](https://tio.run/##7ZNBbhMxFIb3PsU/U9IkTcg0UzWhCWR2KImoRkIsWFRCzthTm0zs1PYoLYgrsGDJAsSeG7DjKD0BNwj2CFpxA4R4sj7/fvaz35P1Cq3Zfn9wQZJEUKzvDK8p/nCw4LF@Wozzq/QVOZCqqGrGH1vHpB6IWZI86I3HrdEhBsFg1hPrqHHYGqncBPFwGAcnVyyLGsuyv3B4INfrQcC9yu7Uf/yz@PXdt@8/Pvr@jSA5IrwQGg8VTqb8Wjoye3rWax22n/UmvcmczPlNHzsqHTcRWXilHNJT6BJOSDsgc73Dpi4EpIV0GXkhOFayqvrYVpxaPiCl1lD@1BmYripqrA8uo8YtqMWKcwXLq0qqS@jaYadNxXaS8YhQPMHwmDS9tfAPU1L6q7nBTlDnE@AojSzWntTTiXqzckExyZisbsDComg2twFXtW9Vbla0ibmP7GyRpl2yrEMVghuf9WxZ93GSktlLLGtiuUOE0@PfYkS03uBc58jzc@DH5w9f01Hg7acv5CjZUKk6MiTcfXvJXSGo6XSnTRllJ26xuG/lG67LThvtbnf6Lkmex@kwviCYpWqspvv9Tw) `a(n) = 25`
* [A000027](http://oeis.org/A000027) in [COW](https://tio.run/##7ZNBbhMxFIb3PsWfKWlmmpBpJmpCE8jsUBJRRUIsWFRCzthTm0zs1PZoWhBX6KJLFiD23IAdR@kJuEHwjKAVN0CIJ@vz72c/@z1ZL9PVfn9wTuJYUGzuDW8p/nCw2mP9tBivLpM35ECqrCgZf2odk7ovZnH8qDset0eH6NcGs5lYR43DzkjlJggGg6B2csXSVmNp@hcOD6z0pl/jQaX36j/@Wfz67rubj0@@fyOIjwjPhMZjheGUX0lHZs9Pu@3DzovupDuZkzm/7qGi0nHTIguvlENyAp3DCWn7ZK4rbMtMQFpIl5JXgmMti6KHXcGp5X2Saw3lT52C6aKgxvrgvNW4BbVYc65geVFIdQFdOlTaFKySjLcIxTMMjknTWwv/MCW5v5obVII6nwBHbmS28aSeTpTbtasVk4zJ4hqsXmTN5q7GZelblZs1bWIeIsMdkiQiy7KuQnDjs54tyx6GCZm9xrIklju0cHL8W4yI1luc6RVWqzPgx@fbr8mo5t2nL@Qo3lKpQlknHL2/4C4T1ITRtCkjD4M2C3pWvuM6DzvoRNH0Qxy/DJJBcE4wS9RYTff74U8) `a(n) = n + 1`
* [A010865](http://oeis.org/A010865) in [Emoji](https://tio.run/##7ZPBbhMxEIbvfoo/W9IkTcg2GzWhCSQ3lERUkRAHDpWQs56t3Wzs1PYqFNRX6IEjBxB33oAbj9In4A2CdwWteAOEGFmff4899oysoY25VPv9wTmLY8mxvjdccvzhEKXHhWk@XF4lb9iB0mleCHrqvFCmKydx/Kg9HNYHh@iWBrseOc@tx9Yq7UeIer2odJIW01pl0@lfOAKwNOtuiQc1vVf/8c/i13ff3X588v0bQ3zEKJUGjzX6Y3qrPJs8P23XDxsv2qP2aMZmdN3BjitPtsbmQWmP5AQmg5fKddnM7LApUgnloPyUvZKElcrzDrY5cUddlhkDHU6dQpg859aF4KxWuSV3WBFpOMpzpS9gCo@dsbnYKUE1xvEMvWNW9dY8PMxZFq4mi53kPiRAyKxK14E80Mtis/KlEkoIlV9DlIu02tyWuCpCq5Jd8SrmIbK5RZK02KIoq5BkQ9aTRdFBP2GT11gUzJFHDSfHv8WAGbPBmVliuTwDfnz@8DUZlLz79IUdxRuudFOVCbfeX5BPJbfN1rgqI2tGdRF1nHpHJms20Gi1xjdx/DJKetE5wyTRQz3e7/s/AQ) `a(n) = 26`
* [A010866](http://oeis.org/A010866) in [><>](https://tio.run/##7ZNBbhMxFIb3PsU/U9IkTcg0UzWhCWR2KImoRkIsWFRCzthTm0zs1PYoLYgrsGDJAsSeG7DjKD0BNwj2CFpxA4R4sj7/fvaz35P1SmnFfn9wQZJEUKzvDK8p/nCw4LF@Wozzq/QVOZCqqGrGH1vHpB6IWZI86I3HrdEhBsFg1hPrqHHYGqncBPFwGAcnVyyLGsuyv3B4INfrQcC9yu7Uf/yz@PXdt@8/Pvr@jSA5IrwQGg8VTqb8Wjoye3rWax22n/UmvcmczPlNHzsqHTcRWXilHNJT6BJOSDsgc73Dpi4EpIV0GXkhOFayqvrYVpxaPiCl1lD@1BmYripqrA8uo8YtqMWKcwXLq0qqS@jaYadNxXaS8YhQPMHwmDS9tfAPU1L6q7nBTlDnE@AojSzWntTTiXqzckExyZisbsDComg2twFXtW9Vbla0ibmP7GyRpl2yrEMVghuf9WxZ93GSktlLLGtiuUOE0@PfYkS03uBc58jzc@DH5w9f01Hg7acv5CjZUKk6MiTcfXvJXSGo6XSnTRllJ26xuG/lG67LThvtbnf6Lkmex@kwviCYpWqspvv9Tw) `a(n) = 27`
* [A010867](http://oeis.org/A010867) in [Set](https://tio.run/##7ZPBbhMxEIbvfoo/W9IkTcg2WzWhCWRvKImoIiEOHCohZz1bm2zs1PYqLYhX4MCRA4g7b8CNR@kT8AbBu4JWvAFCjKzPv8cee0bWOPL7/cEFi2PJsb4zvOb4wyEqjwvTfLS8Sl6xA6WzohT02HmhTF9O4/hBdzRqDg/Rrwx2PXaeW4@tVdqPEQ0GUeUkLdJGbWn6F44ALM26X@FepXfqP/5Z/Pru2/cfH33/xhAfMcqkwUONkwldK89mdNPDjitPtsHmQWmP5BQmh5fK9dnM7LApMwnloHzKXkjCShVFD9uCuKM@y42BDqfOIExRcOtCcN6o3ZI7rIg0HBWF0pcwpcfO2ELslKAG43iCwTGru2keHuYsD1eTxU5yHxIg5FZl60Ae6GW5WflKCSWEKm4gqkVWb24rXJWhOcmueB1zH9neIkk6bPr0rNs8bD3rjrvjGVuUVU2SbKhhuih7OEnY9CUWJXPk0cDp8W8xZMZscG6WWC7PgR@fP3xNhhVvP31hR/GGK91WVfqdt5fkM8ltuzOpi8rbUVNEPafekMnbLbQ6ncm7OH4eJYPogmGa6JGe7Pc/AQ) `a(n) = 28`
* [A010868](http://oeis.org/A010868) in [NTFJ](https://tio.run/##7VNBbhMxFN37FG8mpJk0YaaZqglNYLJDSUQVCbFgUQk5Y0/tZmKntkehIK7AgiULEHtuwI6j9ATcIHgGaMWOJUI8Wc/P3/62n62vXHGZ7/etc5IkgmJ9C1xS/BZgdcT6bj5aXqUvSEuqvKwYf2gdkzoWWZLc641G7eEB4how67F11DhsjVRujHAwCOsgV2waNJhO/8LmCUu9jmu6U9Nb9Z/@Wfr53Tdv3z/4@gWtPwZBckh4LjTuKxxP@EvpyIxf97Gj0nETkLlXyiE9gS7ghLQxmekdNlUuIC2km5JngmMly7KPbcmp5TEptIbyq07BdFlSY31yETRhQS1WnCtYXpZSXUBXDjttSraTjAeE4hEGR6QpvLk/mJLCb80NdoI6fwGOwsh87Zl6dqLarFytmGRMltdg9SBvJrc1XVW@jrlZ0SbnLjPaIk27JHt82msfdJ70xr3xjCyq2pPgxnvIFlUfxynJnmNREcsdApwc/RJDovUGZ3qJ5fIM@Pbx3ed0WPPNh08/nj8hh8mGShXJ2kX39QV3uaAm6k4ab0UUtlnYt/IV10XUQafbnbxJkqdhOgjPCbJUjdRkv/8O) `a(n) = 29`
(Links are not all current, I'll eventually update them. I have verified each language.)
# C/C++
`sizeof(' ')` is 1 in C++ and 4 in C. Here's the C/C++ code:
```
#include <stdio.h>
main(){getchar();printf("%d",sizeof(' '));}
```
* `#include <stdio.h>` is needed for C++. (This is why I don't like it.)
* `getchar();` is there because we still technically need input.
* `printf("%d",sizeof(' ')` prints 4 in C and 1 in C++.
**Update** - the `echo -n 3;exit` is ignored via `\` at the end of the comment on line 1.
# [Cubically](//git.io/Cubically)
Cubically ignores everything it doesn't care about as long as no functions get called.
```
$+7+7%6&
$          read int as input
 +7+7      double it (could be +77, I'll golf everything more if it comes to that)
     %6    print output
       &   exit (the `main()` would cause an infinite loop)
```
# [rk](https://github.com/aaronryank/rk-lang)
rk is horrible, but good for polyglotting. It ignores everything before `rk:start` and after `rk:end`:
```
rk:start print: "11" rk:end
```
Pretty simple. A010850 is a constant sequence. "Input is taken via command line arguments." :P
# [what](https://github.com/gimmetehcodez/what)
The `what` interpreter reads three bytes at a time. Very stupid but useful.
```
?!!!??(x50)??!
```
Gets input (uselessly), goes to next memory cell, adds the ASCII value for 2 (50) to the current memory cell and outputs.
# Bash
```
# <comment>
echo -n 3; exit
<everything ignored because parser already exited>
```
Also takes input via "command line arguments". I love constant sequences.
# [Morse](https://github.com/aaronryank/minproj/blob/master/morse/morse.c)
Morse Code is the oldest language used in this thread, I can guarantee. ;) This uses an interpreter I wrote last year for fun. It conveniently ignores everything it doesn't care about.
```
.....
```
Constant sequences probably weren't what the OP had in mind when creating the challenge...
# Ook!
Ook! is a Trivial Brainf\*\*k Substitution. The interpreter I found is really crappy, reads 11 characters at a time and checks if it's something it cares about. Pasting the code at the end of the first line magically lined it up properly, so the interpreter noticed the Ook! code.
```
Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. 
```
This is equivalent to Brainf\*\*k's `,>+(x48).`. Read a character, move to next memory cell, increment to 48 (ASCII code for `0`) and print.
# [str](https://github.com/ConorOBrien-Foxx/str/)
The str code wanted to be right at the top because something around `#include <stdio.h>` made it bug out. I had to rearrange the what and Ook! code, since I added something before both of them.
```
# // I7Oq
```
`#` is apparently a valid preprocessing token in C/C++. `//` comments it out. (That's a capital letter o, in case your screen tries to deceive you.)
* `I` - read input
* `7` - push 7
* `O` - output
* `q` - turn off STDOUT just in case
I think it's real clever how `I` is for input and `O` is for output. Nice language, Conor!
# [Charcoal](https://github.com/somebody1234/Charcoal)
Wow, I like this language, I'm gonna use it more sometime.
Luckily, there's a command to clear the output buffer, `âŽš`. So it just echoes everything up to the `âŽš` on line 2, then clears that. The Charcoal code we care about looks like this:
```
âŽš8Â»
```
8 prints 8. `Â»` exits with a parse error, which is allowed by default.
# [Commercial](https://github.com/tuxcrafting/commercial)
This one was a bit less nice because it wanted me to have its code on separate lines. I had to rearrange the C/C++ comments a bit.
For some reason, C emitted a warning and then didn't compile when I replaced the `//` with `/*`. So it's on its own line, making Bash annoyed but still prints the desired number.
```
foo now 9 dollars off!
foo has been selling out worldwide!
```
* `variable now x dollars off` creates a new variable `variable` with value `x`.
* `variable has been selling out worldwide!` prints the variable's value.
At least the interpreter is forgiving about *unrecognized* code...
Oh, I also updated all the TIO links. That was a pain so I'll probably only do so every 10 or when I quit working on this polyglot. Fun challenge, thanks!
# [S.I.L.O.S](https://github.com/rjhunjhunwala/S.I.L.O.S)
That had one of the clearest, most concise READMEs I've ever seen. Simple as this:
```
a = 10
printInt 10
```
Adding this code didn't even break anything!
# [Memescript 1.0](https://github.com/aaronryank/memescript-1.0/)
Why does this language exist >.<
The interpreter was being lame so I had to add `filler` to get it to see `what the`.
```
filler what the frick frack thumbtack diddily dack crack pack quarterback frick frack
```
* `what the` - start code
* `frick frack thumbtack` - push 11
* `diddily dack crack pack` - add 5
* `quarterback frick frack` - output as integer
# Forked
Forked is my new 2d lang, it's only partially implemented. It's not in a triangle or a cube or anything interesting, it's just a fun simple esolang.
Unfortunately, having `# // I70q` on the first line had a mirror `/` in the way of the source code. I moved some things around so the mirrors look like this:
```
 \
//
```
The mirrors are pretty self-explanatory; the code enters from the top left and exits at the bottom left. Then it hits this code near the bottom:
```
>F9+%&
```
`>` directs the IP west. `F` pushes 15, `9` pushes 9. `+` adds them, `%` prints as integer, `&` exits.
Note: This may not work in future Forked versions, depending on how `#` will handle invalidity.
# [TRANSCRIPT](https://github.com/TryItOnline/transcript/blob/master/README.txt)
This is a cool language. I don't really understand some of the syntax (specifically, `>`), but it's fun nevertheless. Also forgiving about syntax errors which is why I chose to use it.
Here's the code we care about:
```
Ju is here.
>Ju, 32
>X Ju
```
* `Ju is here.` defines an NPC (variable) named Ju. (Short for Julie, which was used in the example.)
* `>Ju, 32` puts 32 in Ju's memory (sets it to 32).
* `>X Ju` prints Ju. (Where did `X` come from?!?)
# [Braingolf](https://github.com/gunnerwolf/braingolf)
Apparently, the code does some wacked out stuff to the stack but outputs 0 at EOF, so I found a place I could put the code without breaking anything else, found a sequence that ended in 0, and let it do its implicit output at the end.
```
2_
```
Pushes 2 and prints it. `0` is printed at the end, printing 20. More constant sequences, yay!
# [Fission](https://github.com/C0deH4cker/Fission)
For such a complicated language, this was pretty easy - just modified [this](https://chat.stackexchange.com/transcript/message/39301825#39301825):
```
R"21"
```
Prints 21. Surprisingly, putting this *anywhere* in the code worked just fine. 
* `R` creates atom travelling right.
* `"21"` stores the string 21 in that atom.
* Implicit output at the end of the program, I guess.
# [Arcyou](https://github.com/Nazek42/arcyou)
Another language forgiving about syntax errors. Here's the code we care about:
```
(p 22)
```
Arcyou is pretty much identical to LISP, but golfier. `p` is print, `22` is 22.
Also, it printed `None` due to the `main()`. I added `a` there, C++ complained, I made it `int a` and everything's running smoothly again.
# [Beam](http://esolangs.zem.fi/wiki/Beam)
The hardest part about adding this language was finding the spec. Luckily, there's a mirror of esolangs.org! Thanks, totallyhuman!
Beam uses the same control flow as Forked but that's it. So I put its code after Forked's exit command.
```
'L+:+:H
```
`'` increments the store and `L` sets the beam to the store. `+` increments, `:` outputs as integer. 
I tried `++:+:H` first, but the beam apparently is not initialized to 0. The store is, though.
# [Beatnik](http://esolangs.zem.fi/wiki/Beatnik)
Beatnik is a language almost as awful as some I've written and am planning to write. It uses Scrabble word values. Here's its code:
```
ha kkkkkkkkkk ja ha kkkkkkkkkkd ja skd
```
Here is the Scrabble values for those:
```
5 50 9 5 52 9 17
```
* `5 50` - push 50
* `9` - print as ASCII
* `5 52` - push 52
* `9` - print as ASCII
* `17` - exit
I used a comma and a bunch of Z's initially, which messed with str. Fixed by removing the useless comma and changing 5 z's to 10 k's.
# [Cood](https://github.com/jesobreira/cood)
Cood cares about this (explanation on the right)
```
Hey, waiter!           (start program)
I want 25 of this.     (set memory to 25)
How much is it?        (print as int)
The bill, please.      (finish script)
```
# [COW](https://bigzaphod.github.io/COW/)
Yay, a non-constant sequence! :D
```
oom MoO OOM
oom          read integer
    MoO      increment
        OOM  print as integer
```
# Emoji
```
ðŸ’¬26ðŸ’¬âž¡
ðŸ’¬..ðŸ’¬   push string
 26    "26"
    âž¡  print top of stack
```
# ><>
Another language I'm going to use more; I love how this wraps.
It initially hits `#`, which bounces the IP backwards, wraps around, hits `\`, which wraps vertically to the bottom, hits `>`, then it sees `2n7n;`.
```
2n7n;
2      push 2
 n     output
  7    push 7
   n   output
    ;  exit
```
# Set
I recall this being used in the [answer-chaining](/questions/tagged/answer-chaining "show questions tagged 'answer-chaining'") [polyglot](/questions/tagged/polyglot "show questions tagged 'polyglot'"). Luckily, ASCII-only's TIO interpreter doesn't care about syntax errors!\
```
set ! 50         (print 2)
set ! 56         (print 8)
```
# [NTFJ](https://github.com/ConorOBrien-Foxx/NTFJ)
That's another one of your langs I've used, Conor.... this is possibly the strangest. All I do is push truthy values (`#`) and use `/` to push the number of items on the stack to the stack and `*` to print.
```
(line 3) ##########################################
(line 4) /*
(line 21) #####/
(line 22) *
```
I didn't really mess with the code in the middle. It probably does things to the stack, and this will probably be a pain down the road, but whatever, it works.
[Answer]
# 9 Languages, 217 bytes
```
2/3#^4 9 
    
    
5   
if 1:
  x="+++++++[>+++++++<-]>."#3
  R = input()
  try:
    print(int(eval(chr(49)+chr(47)+chr(40)+chr(49)+chr(47)+chr(50)+chr(41))*int(R)))
  except:
    print(7**int(R))
    R="6"#N;
    n=2
  R
```
* In [Jelly](https://tio.run/##y0rNyan8/99I31g5zkTBUoFLQYGTi5PLFEhmpikYWgH5FbZK2hAQbQdl2OjG2ukpKRsDZYMUbBUy8wpKSzQ0gbySokqQFgWFgqLMvBINEE4tS8zRSM4o0jCx1NQG0@ZQ2gBKo4mbwsQNNTW1QCYEaWqCzE6tSE4tKEE23lwLJg8WDLJVMlNS9rMGc/JsjUCu@///vwkA), produces [A000027](https://oeis.org/A000027).
* In [Python2](https://tio.run/##K6gsycjPM/r/30jfWDnORMFSgUtBgZOLk8sUSGamKRhaAfkVtkraEBBtB2XY6Mba6SkpGwNlgxRsFTLzCkpLNDSBvJKiSpAWBYWCosy8Eg0QTi1LzNFIzijSMLHU1AbT5lDaAEqjiZvCxA01NbVAJgRpaoLMTq1ITi0oQTbeXAsmDxYMslUyU1L2swZz8myNQK77/98EAA), produces [A000420](https://oeis.org/A000420).
* In [Python3](https://tio.run/##K6gsycjPM/7/30jfWDnORMFSgUtBgZOLk8sUSGamKRhaAfkVtkraEBBtB2XY6Mba6SkpGwNlgxRsFTLzCkpLNDSBvJKiSpAWBYWCosy8Eg0QTi1LzNFIzijSMLHU1AbT5lDaAEqjiZvCxA01NbVAJgRpaoLMTq1ITi0oQTbeXAsmDxYMslUyU1L2swZz8myNQK77/98EAA), produces [A005843](https://oeis.org/A005843).
* In [Brainfuck](https://tio.run/##SypKzMxLK03O/v/fSN9YOc5EwVKBS0GBk4uTyxRIZqYpGFoB@RW2StoQEG0HZdjoxtrpKSkbA2WDFGwVMvMKSks0NIG8kqJKkBYFhYKizLwSDRBOLUvM0UjOKNIwsdTUBtPmUNoASqOJm8LEDTU1tUAmBGlqgsxOrUhOLShBNt5cCyYPFgyyVTJTUvazBnPybI1Arvv/HwA), produces [A000012](https://oeis.org/A000012).
* In [///](https://tio.run/##K85JLM5ILf7/30jfWDnORMFSgUtBgZOLk8sUSGamKRhaAfkVtkraEBBtB2XY6Mba6SkpGwNlgxRsFTLzCkpLNDSBvJKiSpAWBYWCosy8Eg0QTi1LzNFIzijSMLHU1AbT5lDaAEqjiZvCxA01NbVAJgRpaoLMTq1ITi0oQTbeXAsmDxYMslUyU1L2swZz8myNQK77/x8A), produces [A007395](https://oeis.org/A007395).
* In [Ohm](https://tio.run/##y8/I/f/fSN9YOc5EwVKBS0GBk4uTyxRIZqYpGFoB@RW2StoQEG0HZdjoxtrpKSkbA2WDFGwVMvMKSks0NIG8kqJKkBYFhYKizLwSDRBOLUvM0UjOKNIwsdTUBtPmUNoASqOJm8LEDTU1tUAmBGlqgsxOrUhOLShBNt5cCyYPFgyyVTJTUvazBnPybI1Arvv/HwA), produces [A010734](https://oeis.org/A010734).
* In [><>](https://tio.run/##S8sszvj/30jfWDnORMFSgUtBgZOLk8sUSGamKRhaAfkVtkraEBBtB2XY6Mba6SkpGwNlgxRsFTLzCkpLNDSBvJKiSpAWBYWCosy8Eg0QTi1LzNFIzijSMLHU1AbT5lDaAEqjiZvCxA01NbVAJgRpaoLMTq1ITi0oQTbeXAsmDxYMslUyU1L2swZz8myNQK77/x8A), produces [A010709](https://oeis.org/A010709).
* In [Fission 2](https://tio.run/##S8ssLs7MzzP6/99I31g5zkTBUoFLQYGTi5PLFEhmpikYWgH5FbZK2hAQbQdl2OjG2ukpKRsDZYMUbBUy8wpKSzQ0gbySokqQFgWFgqLMvBINEE4tS8zRSM4o0jCx1NQG0@ZQ2gBKo4mbwsQNNTW1QCYEaWqCzE6tSE4tKEE23lwLJg8WDLJVMlNS9rMGc/JsjUCu@/8fAA), produces [A010722](https://oeis.org/A010722)
* In [Whitespace](https://tio.run/##K8/ILEktLkhMTv3/30jfWDnORMFSgUtBgZOLk8sUSGamKRhaAfkVtkraEBBtB2XY6Mba6SkpGwNlgxRsFTLzCkpLNDSBvJKiSpAWBYWCosy8Eg0QTi1LzNFIzijSMLHU1AbT5lDaAEqjiZvCxA01NbVAJgRpaoLMTq1ITi0oQTbeXAsmDxYMslUyU1L2swZz8myNQK77/x8A), produces [A0000004](https://oeis.org/A000004)
Jelly outputs the first `n` elements of the sequence instead of the `n`-th element.
><> and Whitespace exit with an error after giving the correct output, which is allowed by default.
## How it works
**Jelly**
Jelly sees only the `R` at the bottom, which tells it to output `range(input)`.
**Python 2**
After removing unused lines, Python 2 sees:
```
if 1:                     # just do it, where it is the following:
  R = input()             # set input to R
  try:                    # try:
    print(int(eval(chr(49)+chr(47)+chr(40)+chr(49)+chr(47)+chr(50)+chr(41))*int(R))
  # print(int(1/(1/2))*int(R)). Floor division causes 1/(1/2) to be
  # 1/0, raising a division by 0 error, going into the except block
  except:
    print(7**int(R))      # print 7 to the power of R.
```
**Python 3**
```
if 1:                     # just do it, where it is the following:
  R = input()             # set input to R
  try:                    # try:
    print(int(eval(chr(49)+chr(47)+chr(40)+chr(49)+chr(47)+chr(50)+chr(41))*int(R))
  # print(int(1/(1/2))*int(R)). Float division causes 1/(1/2) to be
  # 1/0.5=2. This is multiplies by R and printed.
  except: # The except block is not called
    print(7**int(R))
```
**Brainfuck**
Brainfuck sees:
```
+++++++    Set counter cell to 7
[          While counter != 0
  >          Go to storage cell (default to 0)
  +++++++    Increase by 7
  <          Return to counter cell
  -          Decrement
]          EndWhile
>.         Print out chr value of storage cell => chr(49) = "1"
```
**///**
/// sees:
```
<Something including the top-left 2>
# replace the empty string with 2 and output
```
**Ohm**
Ohm sees:
```
<Something including the top 9>
# implicitly output 9.
```
**><>**
><> sees:
```
2/3#^4 9   -- the IP travels right (pushing 2) until it hits `/`
 f         -- it travels up (pushing f=15) until it hits `/`
           -- it travels right (pushing 3) until it hits `#`
           -- it travels left (pushing 3) until it hits `/`
           -- it travels down (pushing f=15) until it hits `/`
           -- it travels left (pushing 2 then 9 then 4) until it hits `^`
           -- it travels up. When it hits `n`, it prints the 4
           -- it then hits some characters ><> doesn't like,
           -- ending the program with an error.
    n
  
```
**Fission**
Fission sees:
```
R="6"#N;
R          - start an IP/atom going right
  "        - start string
   6       - 6
    "      - end string
      N    - add newline
       ;   - end program. (implicit) print
```
(it sees other lines, but those don't affect output)
**Whitespace**
Some of this has likely been lost in copy-paste.
Whitespace sees the following, where N represents linefeed, S represents space, and T represents tab. All actual newlines should be ignored.
```
NSSN
SSSN  -- push 0
TN    -- print it
NTNSNSSNSSSSNSSNSSSSNSSNSSSSNSSSSNSSSSNSSN
```
[Answer]
# 9 Languages, ~~107~~ 98 bytes
Sub 100!
Python 2, Python 3, JavaScript, PHP, brainfuck, Retina, Gaia, ><>, Ohm.
```
2 //1;""""0
;function a($n){return $n**(2+!"0");};
/*."""
print(input()*2)
1#/i$%o<
() #\7751cep*/
```
[A005843](http://oeis.org/A005843) in [Python 2](https://tio.run/##DcrBCgIhEADQ@3yFuQYzEzQqxB7sU7rEspGXUUQPEX277Tu/@unvonHOaERCsgcP6TV067moeaJT@ra9j6bGKTPGy8l6S@mXQPh6dKgta8esdXQkjgRhkezO5Q5IZnms6y1se2WZM/g/)
[A020338](http://oeis.org/A020338) in [Python 3](https://tio.run/##DcqxCsMgEADQ3a@wxsJ5hZ5aQgb7KV1KSKnLKXIOoeTbbd786i7fwo8xoiYKyZy8Sp/Oq@TC@g2W3a9t0htry4gQbxfjjUtHUoT3s6vaMgtkrl3AYXQqTJTttTwVOD29lmUO61aRxgj@Dw)
[A000290](http://oeis.org/A000290) in [JavaScript](https://tio.run/##DcpLDsIgEADQPafAFpMZjOWTNF3gUdwQRINpBkKpG@PZsW/93v7jt1BTaVfKj9i75UoZNxw0c8@dQkuZuAdB@K2x7ZW4ICnBXk6DHtD9HFNyOjorNVGDRGVvgNIiM6NK4pxvDJCP92WZTYhFqh4ybXmN05pf4MFoxP4H)
[A000578](http://oeis.org/A000578) in [PHP](https://tio.run/##DYy7CgMhEAD7/QrjGXANxAeEKzzIj6QJYjibdRGtQr7dOMVUw/DJ83jychDW@igXDuJnUOqlknhrRfhtuY9GQpExOtwu0kmMvwjW3FcO3Ap1XYhH12gCgt9sUdd6gEaxvfb94VNmY2dOZ11H7zDOPw) (run with `-r`)
[A000012](https://oeis.org/A000012) in [brainfuck](https://tio.run/##DcpBCsMgEADAu6@wxsLuFmoUSg7mKblYSWApbET0VPp2mznPuyaWo@fPGEE756O5zCoeXXLjU3QCK/ite@tVtBUiCI@bmQ3GX1SOnldXpbI0YCm9AVJA5SfH9n6uClBP27K8fN4LuTHSHw) (IO by byte value)
[A001477](http://oeis.org/A001477) in [Retina](https://tio.run/##DcrBCsMgDADQe77CWQfGwaLC6MF9yi6lOMglFYmnsm93fefXq7Jsc2ZDlIq9RCjfIbvyIWbzTvDsVUcX4yQEnx83Gy2WXwEKz6tD6yzqWdpQjyEjpIXY3Y83eDTLZ11faa8t0Jwp/gE)
[A000040](https://oeis.org/A000040) in [Gaia](https://tio.run/##Dco7CsMwDADQXadwHRckFeoPlAzuUbqYkBYtijH2VHp2N29@nyJlzmS8j9meAuT30K3LoaagU/q2vY@mxikzptvFBkv5l8Hz/exQm2hH0To6EieCuHhx1@MJSGZ5resjbntlP2cMfw)
[A000035](https://oeis.org/A000035) in [><>](https://tio.run/##DcrBCsMgDADQe77CWQcmg6UKowf7KbuU0rJcUnF6Gvt223d@u3w/vUfDHJK9jJD2pmuVQ83ineKvbLUVNU6JfHzc7Ggx/RMwPa8OuYhWL5pb9UgRIQws7n7M4NEM72l6hXXLxL0vJw) (IO by byte value)
[A000004](http://oeis.org/A000004) in [Ohm](https://tio.run/##DcrBCgIhEADQ@3yFuQYzEzQqxB7sU7rEspGHRhE9Rd9u@86vvD9zRiMSkj14SK@hW89FzROd0rftfTQ1TpkxXk7WW0q/BMLXo0NtWTtmraMjcSQIi2R3LndAMstjXW9h2yvLnMH/AQ)
## Explanations
### Python 2 and 3
All the two Python versions see is the following:
```
print(input()*2)
```
The difference in their behaviour is that `input()` evals the line of input read in Python 2, but just returns the string in Python 3. So Python 2 prints **2n**, but Python 3 prints the string of **n** repeated twice.
### JavaScript and PHP
What these languages see is the following:
```
2
;function a($n){return $n**(2+!"0");};
```
Which defines a function `a` that computes the result. The difference in behaviour comes from `!"0"`. 
In JavaScript, `"0"` is a truthy value. So `!"0"` becomes `false`, which gets cast to 0. Thus JavaScript computes `$n` to the power 2+0. 
In PHP, the `"0"` is actually a falsy value, because (for whatever reason) it gets cast to the number `0` before being treated as a boolean. So `!"0"` is true. Thus PHP computes `$n` to the power 2+1.
### brainfuck
The `+` in the JS/PHP part increments the cell, then the `.` in the middle outputs it. Thus it outputs the byte value 1 for any input.
### Retina
Retina does a lot of regex substitutions on the input, using regexes that don't even remotely match any number that would be given as input (so no replacements are made). Then it prints the result of the replacements, which is just the input.
### Gaia
The only line executed by Gaia is:
```
() #\7751cep*/
(               Decrement the input
 ) #            Find the first (input-1) numbers such that (number+1) is true
    \           Delete that list of numbers
     7751c      Push the string "á¹‡"
          e     Eval it (the command for "nth prime number")
           p    Print the result
            */  Some other stuff that doesn't matter
```
### ><>
What's relevant to ><> is
```
2 /
  /i$%o<
```
The fish starts at the top left, pushing `2`. It moves over to the `/`, mirroring and looping to the bottom of the code. It hits the other `/` and move right. It pushes input (`i`), swaps the top stack elements (`$`), computes input mod 2 (`%`), and outputs as a byte (`o`). Then it moves left and tries to output again, which causes the program to exit with an error since there's nothing left on the stack.
### Ohm
Ohm only executes the first line:
```
2 //1;""""0
```
Which is some random stuff and then `0`. Only the top stack element is printed implicitly.
[Answer]
# 5 languages - [Braingolf](https://github.com/gunnerwolf/braingolf), [Pyth](https://pyth.readthedocs.io) / [GolfScript](http://www.golfscript.com/golfscript/) / [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak) / [Pyke](https://github.com/muddyfish/PYKE) / [Brachylog](https://github.com/JCumin/Brachylog), [MATL](https://github.com/lmendo/MATL), [Retina](https://github.com/m-ender/retina) / [Jelly](https://github.com/DennisMitchell/jelly) / [Commentator](https://github.com/SatansSon/Commentator) and [05AB1E](https://github.com/Adriandmen/05AB1E) / [2sable](https://github.com/Adriandmen/2sable) / [Oasis](https://github.com/Adriandmen/Oasis)
```
Q
```
This has ~~two~~ three multi-language-sequence polyglots. In Braingolf, this computes the triangular numbers ([A000217](https://oeis.org/A000217)), Pyth and GolfScript and Pyke (and Brain-Flak) are 0-indexed and use the non-negative integers ([A001477](https://oeis.org/A001477)), MATL is 0-indexed and uses the positive integers ([A000027](https://oeis.org/A000027)), Retina, Commentator and Jelly always output `0` ([A000004](https://oeis.org/A000004)), regardless of the input and 05AB1E, Oasis and 2sable always output `1` ([A000012](https://oeis.org/A000012)).
* **[Try Braingolf online!](https://tio.run/##SypKzMxLz89J@/8/8P///yYA)**
* **[Try Pyth online!](https://tio.run/##K6gsyfj/P/D/fxMA)** or **[Try GolfScript!](https://tio.run/##S8/PSStOLsosKPn/P/D/f0MA)** or **[Try Pyke!](https://tio.run/##K6jMTv3/P/D/fwMA)** or **[Try Brachylog!](https://tio.run/##SypKTM6ozMlPN/r/P/D/f@P//gA)** (thanks to @DanTheMan) or **[Check out Brain-Flak instead!](https://tio.run/##SypKzMzTTctJzP7/P/D/f0MA)**
* **[Try MATL online!](https://tio.run/##y00syfn/P/D/fxMA)**
* **[Try Retina online!](https://tio.run/##K0otycxL/P8/8P9/EwA)** (thanks to @jimmy23013) or **[Try Jelly!](https://tio.run/##y0rNyan8/z/w/38TAA)** or **[Check out Commentator instead!](https://tio.run/##S87PzU3NK0ksyS/6/z/w/38TAA)**
* **[Try 05AB1E online!](https://tio.run/##MzBNTDJM/f8/8P9/C2NLEwA)** or **[Try 2sable!](https://tio.run/##MypOTMpJ/f8/8P9/EwA)** or **[Check out Oasis instead!](https://tio.run/##y08sziz@/z/w/38TAA)**
---
# How?
In Braingolf, the nth triangular number is calculated using `Q` (1-indexed).
In Pyth and GolfScipt and Pyke (and Brain-Flak), the input just gets printed as it is.
In MATL, `Q` means increment by 1, hence it displays the number given as input plus 1.
In Retina, Commentator and Jelly, `Q` always prints `0`. Similarly, 05AB1E, Oasis and 2sable output `1`.
[Answer]
# 5 languages ([05AB1E](https://github.com/Adriandmen/05AB1E), [CJam](https://sourceforge.net/projects/cjam/), [Jelly](https://github.com/DennisMitchell/jelly), [MATL](https://github.com/lmendo/MATL), [Retina](https://github.com/m-ender/retina)), 8 bytes
```
rdK*p
%2
```
This produces:
* In [05AB1E](https://tio.run/##MzBNTDJM/f@/KMVbq4BL1ej/f0MDAA): sequence [A007395](https://oeis.org/A007395);
* In [CJam](https://tio.run/##S85KzP3/vyjFW6uAS9Xo/38zAA): sequence [A008602](https://oeis.org/A008602);
* In [Jelly](https://tio.run/##y0rNyan8/78oxVurgEvV6P///0bmAA): sequence [A000035](https://oeis.org/A000035);
* In [MATL](https://tio.run/##y00syfn/vyjFW6uAS9Xo/39DEwA): sequence [A000012](https://oeis.org/A000012);
* In [Retina](https://tio.run/##K0otycxL/P@/KMVbq4BL1ej/f2MTAA): sequence [A000027](https://oeis.org/A000027).
The CJam program exits with an error after producing the correct result in STDOUT, which is [allowed by default](https://codegolf.meta.stackexchange.com/a/4781/36398).
[Answer]
# 3 languages, [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), [QBasic](https://drive.google.com/open?id=0B0R1Jgqp8Gg4UVliSTE0MzdLcEU) and [Javascript](https://tio.run/##y0osSyxOLsosKNEtLshMSS3Kzc/LTq38/19d3VpfK4ErM6@gtEQhkcs@UauQS11dSz/NVkPT1s7Q@n9yfl5xfk6qXk5@ukaahqam9X8A)
```
'';/*`
input a
?a*q
''*/f=()=>1;
```
## [QBasic, all 0's; A000004](https://oeis.org/A000004)
```
'';/*`          the ' makes this a comment for QBasic
input a         this asks for an input, stores it in a
?a*q            Multiplies a by q, which is not set in QBasic and therefore 0. ? prints this.
''*/f=()=>1;    And another comment
```
## [QBIC, positive ints, A000027](https://oeis.org/A000027)
```
'';/*`          The ' opens a code literal: This tells the QBIC interpreter that the next bit is pure QBasic. 
                The following ' injects a comment in the output QBasic code, the ` at the end closes the code literal.
input a         this does the same as the QBasic bit
?a*q            Multiplies a by q, which is 1 in QBIC and just yields the input. ? prints this.
''*/f=()=>1;    And another comment
```
## [Javascript, all 1's, A000012](https://oeis.org/A000012)
```
'';/*`          ''; is mostly harmless. /* opens a multiline comment. ` is ignored
input a         commented
?a*q            and commented
''*/f=()=>1;    This closes the comment and defines function f() that always just returns 1
```
[Answer]
# 3 languages: [Gaia](https://github.com/splcurran/Gaia), [CJam](https://sourceforge.net/p/cjam), [Retina](https://github.com/m-ender/retina), 7 bytes
```
1_0
@+
```
[A005843](http://oeis.org/A005843) in Gaia, [A010850](http://oeis.org/A010850) in CJam, and [A000004](http://oeis.org/A000004) in Retina.
[Try it Gaia!](https://tio.run/##S0/MTPz/3zDegIvLQRvIMAAA "Gaia â€“ Try It Online")
[Try it CJam!](https://tio.run/##S85KzP3/3zDegIvLQRvIMAAA "CJam â€“ Try It Online")
[Try it Retina!](https://tio.run/##K0otycxL/P/fMN6Ai8tBG8gwAAA "Retina â€“ Try It Online")
### Explanations
**Gaia**
Gaia only executes the bottom line, which reads input (`@`) and adds it to itself.
**CJam**
```
1      Push 1
 _     Copy it
  0    Push 0
   @   Bring the bottom 1 to the top
    +  Add 1+0, making the stack `[1 1]`. Implicity push the stack flatten and joined.
```
**Retina**
Replaces instances of `1_0` in the input with nothing. Then counts and outputs the matches of the regex `@+` in the result. Since this won't ever appear, it outputs 0 for any *n*.
[Answer]
# 11 languages: C, C++, JavaScript (nodejs), Ruby, JavaScript (modern browser), Perl, dc, ><>, brainfuck, JavaScript (spidermonkey), and Pyramid Scheme, 342 bytes
I wanted to see if I could break ~~9~~ 10. I decided to use mainly non-esoteric languages.
```
        //;<<E;#6nq>>>-[++>+[+<]>]>^\
/*   ;n7<>>                       / \:
#include <stdio.h>              //out\
//                              ^-----
//                              -
struct k {};int main(){printf("%i",1+sizeof(struct k));}
//;\ 
E
//;\
`echo`;  print($??3:5)
;//;#*/  console['log'](this['window']?4:this['print']?9:10)
```
Results I was able to verify (for input 4) on my machine:
```
Result in "C" (A000004):
> gcc normal.c -o normal && normal.exe 4
1
Result in "C++" (A000012):
> g++ normal.cpp -o normal && normal.exe 4
2
Result in "JavaScript" (A007395):
> node normal.js 4
10
Result in "Ruby" (A010701):
> ruby normal.rb 4
3
Result in "Perl" (A010716):
> perl -f normal.pl 4
5
Result in "dc" (A010722):
> echo 4 | dc -f normal.dc
6
```
[Pyramid Scheme](https://tio.run/##hY7NTsMwEITvfopVA4rdEExVfkRsOac@RZKqleMSi8QusaMKqj57MKFcEKLfZTW7M6Pdv/fbTtepk43q1DjCGUoZ5ysWPZo3IURaJIlIioRXohLrEtF5sDDzxIWAv6FQZijSRrZDrYA7X2t72/xyU2oHH9oo/Ms6/eKiLUXO94P08ArHE9PGQ7fVBpPjvg9ih2fXenazSJz@UHaHf7yEsFOoZiWg1TTRRsnGbhjAlMNXeb7MHghi4RjNww/SGmdbVcStfYkr7BvtivigTW0PcZXfZ9@LKRz0c7a4I@P4CQ "Pyramid Scheme â€“ Try It Online")
[Answer]
# 2 languages: /// and ><>
```
/9/0//8/0//7/0//6/0//5/0//4/0//3/0//2/0//1/0//00/0//
>1n;//
```
**///** outputs <https://oeis.org/A000004> all 0's, and **><>** does <https://oeis.org/A000012> all 1's
[Try ><> online!](https://tio.run/##S8sszvj/X99S30Bf3wJEmIMIMxBhCiJMQIQxiDACEYYgwsAARHLZGeZZ6@v///9ft0zB0AAA)
[Try /// online!](https://tio.run/##K85JLM5ILf7/X99S30Bf3wJEmIMIMxBhCiJMQIQxiDACEYYgwsAARHLZGeZZ6@v/NzQw@A8A)
[Answer]
# 4 languages, [Braingolf](https://github.com/gunnerwolf/braingolf), [2col](https://gunnerwolf.github.io/2col/index.php), [arcplus](https://gunnerwolf.github.io/arcplus/index.php), [Lean Mean Bean Machine](https://github.com/gunnerwolf/lmbm)
```
 O
 2
+$
_/
1_
; 
(p
4)
3 
```
That's right! I've successfully created a polyglot of all of my own languages!
# Braingolf, [A000012](https://oeis.org/A000012), the all 1s sequence.
[Try it online!](https://tio.run/##SypKzMxLz89J@/9fwZ9LwYhLW4UrXp/LMJ7LWoFLo4DLRJPLWOH/fwA "Braingolf â€“ Try It Online")
Braingolf usually has implicit output of the top of the stack at program termination, but the semicolon prevents that. As a result, the only important code is this:
```
1_
; 
```
`1_` pushes 1, then pops and prints the top of the stack, while `;` suppresses implicit output. There are no other braingolf print operators in the code, so nothing else is printed.
However it's a little more difficult than that, as polyglots tend to be. The `$` on line 3 is LMBM's "print value" operator, but is Braingolf's "silent" operator. This means that normally the `$` would "silence" the `_` in Braingolf, and cause it to silently pop the top of the stack. As a result we throw in an extra line:
```
_/
```
The slash is explained under LMBM, but the underscore is for Braingolf, it pops the top of the stack *before* we push the 1, consuming the silent operator in the process. This allows our `1_` to function as expected.
# 2col, [A010701](https://oeis.org/A010701), the all 3s sequence.
[Try it in 2collIDE!](https://gunnerwolf.github.io/2col/index.html?code=IE8KIDIKKyQKXy8KMV8KOyAKKHAKNCkKMyA)
2col is to blame for the peculiar layout of the code, as 2col requires every line to be no more than 2 characters in width. Some of these lines do some weird stuff in 2col, but ultimately as there is no valid 2col print operator in this code, the implicit output kicks in and outputs the return value of the last line.
```
3
```
This is the last line, an integer literal, which returns itself.
2col is also the cause of the `+` on line 3. This does nothing, but prevents 2col throwing a TypeError when trying to execute the `$` command.
# arcplus, [A010709](https://oeis.org/A010709), the all 4s sequence.
[Try it online!](https://gunnerwolf.github.io/arcplus/index.html) (code not included)
arcplus is inspired by arcyou, which is inspired by LISP. arcplus ignores everything not in parentheses. Here's the bit in parentheses:
```
(p
4)
```
This is a function call. Specifically the `p` function, which is shorthand for `print`. Any whitespace is valid separator between the function name and the argument, including a newline, so this is essentially `(print 4)`. I hope I don't need to explain what that does.
# Lean Mean Bean Machine, [A007395](https://oeis.org/A007395), the all 2s sequence.
*No online interpreter available*
This one was surprisingly easy, despite being a rather awkward 2d language. Here's what matters for LMBM:
```
 O
 2
+$
_/
1_
; 
```
`O` is a spawn point. A marble is spawned here with a spin of 1, and a value of 0. It hits the 2, setting its value to 2, then hits the `$`, printing its value. The `/` moves the marble one space to the left, and changes its spin to 0, *note that the underscore to the left of the slash is not executed, as "gravity" takes effect after the left shift before the marble has time to execute another symbol.* The marble then drops to 1, setting its value to 1, and finally hits the semicolon, silently killing the marble. LMBM terminates once all marbles are destroyed.
[Answer]
# 30 languageversions, 4 bytes
```
B3%0
```
This works with 30 different versions (cube sizes) of Cubically.
# I promise I'm not cheating!
However, I'd appreciate it if this answer didn't get accepted. There are other more impressive polyglots, including [my other (previously winning) one](https://codegolf.stackexchange.com/a/137874/61563).
> 
> Language (Python 2/3) revisions do count as different languages. Different implementations of a language (such as Browser JS vs Node.js) also count as different languages.
> 
> 
> 
This works in 30 different cube sizes a.k.a. versions of [Cubically](//git.io/Cubically). I added support for multiple cube sizes last night and made changes live this morning. Each cube size is considered a different language version due to the fact that each cube size *completely* changes how math is done in the language.
I realized afterwards that this feature is very useful for polyglotting. As making the change was very difficult, useful for lots of things, and required hours of messing with dynamic memory in C, I clearly did not add it just for that reason.
# Explanation
`B3` turns the BACK face 90° clockwise three times. In Cubically 3x3x3, faces have nine cubelets (three per line), so this gets the cube to look like this:
```
   111
   000
   000
511222330444
511222330444
511222330444
   555
   555
   333
```
That's useful, because in Cubically 4x4x4, it looks like this:
```
    1111
    0000
    0000
    0000
5111222233304444
5111222233304444
5111222233304444
5111222233304444
    5555
    5555
    5555
    3333
```
# Run-down
```
Version   Sequence
2x2x2     A007395
3x3x3     A010701
4x4x4     A010709
5x5x5     A010716
6x6x6     A010722
7x7x7     A010727
8x8x8     A010731
9x9x9     A010734
10x10x10  A010692
...       ...
32x32x32  A010871
```
Looks like the constant sequences *finally* stopped at 32. Seems random but there you are.
[Answer]
# C89, C99, C++, Bash, Python
Look, ma, no esolangs!
```
#include<stdio.h>/*
"""
"; */int x=32//*
/4+//* */
4;/*
echo 3;exit
"""
#*/
#define print(y)main(){printf("%d",x-(int)sizeof(' '));}
print(2)
```
This prints:
* <https://oeis.org/A010709> in C89
* <https://oeis.org/A010731> in C99
* <https://oeis.org/A010850> in C++
* <https://oeis.org/A010701> in Bash
* <https://oeis.org/A007395> in Python
# C89
Single-line comments did not exist in C89, so it sees this:
```
#include<stdio.h>
     int x=32/
4;
#define print(y)main(){printf("%d",x-(int)sizeof(' '));}
```
So `x` is 8, `sizeof(' ')` is 4, outputs 4.
# C99
Single-line comments *did* exist in C99, so it sees this:
```
#include <stdio.h>
     int x=32
/4+
4;
#define print(y)main(){printf("%d",x-(int)sizeof(' '));}
```
So `x` is set to 12, `sizeof(' ')` is 4, output is 8.
# C++
C++ sees the same thing as C99 but `sizeof(' ')` is 1. Outputs 11.
# Bash
Bash sees this:
```
"""
"; */int x=32//*
/4+//* */
4;/*
echo 3;exit
```
Okay, so those first four lines cause a lot of parsing errors. Other than that, prints 3.
# Python
Python sees this:
```
print(2)
```
Everything else is commented out one way or another. Prints 2.
]