This is an answer-chaining challenge where every part of your answer should aim to be unique from every other answer.
This question will work in the following way:
- I will post the first answer. The next answer will stem from that, and all other answers will originate from it.
- In this answer I will include a program and specify three things:
- The language the program is written in
- The integer it outputs
- The bytes the next program must use
- The next user will then write an answer, and specify the same three things - the language they used, the integer they output and the bytes the next program must use
- And so on, until the chain ends.
Each answer will do the following:
It will include a program, written in a language that hasn't been used by any previous answer.
The program outputs an integer, through one of our standard I/O formats, that no previous answer in the chain has outputted before. This integer must be deterministic and consistent between executions, and may be positive, negative or \$0\$.
It only uses the bytes allowed to it by the previous answer. It may use each byte as many times as it likes, but each byte must be used at least once.
The answer will specify a set of bytes (containing no duplicates) that the next answer must use. This set of bytes may not have been used by any previous answer, and can be any subset of the integers between \$0\$ and \$255\$. There must be a minimum of 1 and a maximum of 256 bytes in this subset, and the number of bytes must be unique of all existing answers (i.e. if one answer allows the next to use 120 bytes, no other answer may allow 120 bytes).
Through this, each new answer will determine how difficult (or easy) the next answer is; only allowing a small subset of bytes will make it substantially more difficult than if allowing a larger set. "Bytes" means that you may use languages with non-UTF-8 encodings, by simply taking the characters those bytes represent in that code page.
For the sake of fairness, the first answer (which I'll post) will have all 256 bytes available to it, so that the answers truly are unique in all the specified ways.
Your score is the number of answers you have in the chain, with a higher score being better.
Please format your answer in the following way:
# [N]. [Language], [# of bytes available] available bytes [program] This outputs [output] This uses the characters [characters/bytes], allowed by [previous answer](link) The next answer may use the following bytes: [list of bytes]
- You must wait an hour between posting two answers
- You may not post two answers in a row
- So long as they're unique, the language, integer and bytes are up to your choice
- You are under no obligation to golf your code
- You may submit either a full program or function
- Different versions of languages (e.g Python 2 and Python 3) are not considered separate languages. As a general rule, if the only way the language names differ is by a version number, or if the languages are usually thought of as versions of each other, they are considered the same language.
- You may use any language that wasn't specifically invented to answer this challenge
- The chain ends when 14 days pass with no new answers being posted or after 256 answers have been posted (as no new byte sets will be available).