title: Quickly! Group together!

text:
# Question
Title: Quickly! Group together!
> As of 27/12/20, the challenge is over as no new answers were posted on the 26th. With an astounding 55 points (and 21 answers), the winner is pppery!
>
> A quick shout out to the top 5 scorers as well:
>
> * 1st. pppery with 55 points across 21 answers
> * 2nd. tsh with 50 points across 21 answers
> * 3rd. SunnyMoon with 21 points across 6 answers
> * 4th. NieDzejkob with 17 points across 4 answers
> * 5th. pxeger with 16 points across 7 answers
>
> A full table of everyone's daily scores can be found below. Empty cells indicate no answer

---

This challenge will function somewhat like an question, in that new answers will (somewhat) depend on old answers. However, this is (as far as I can tell) a unique form of , so be sure to read the entire challenge if you'd like to take part.

Normally, challenges work in increments of answers. Each new answer is related to the previous answer, and so on. However, in this challenge, we will change the increments from single answers to single days.

Here's a step-by-step breakdown of how the challenge will work:

* The challenge will be posted at exactly 00:00UTC
* From then until 23:59UTC, users may post answers that complete the **task** (specified below) while also following some of the **restrictions** (also specified below). Each answer will include:
    + A language available to be used
    + A program in that language which completes the **task**
    + A single **restriction** on the source code of new answers
* At 00:00UTC, the **restrictions** will update from those listed in the body of the challenge, to those listed by answers posted the previous day.
* Repeat the previous 2 steps until the challenge ends.

## Task

All answers, regardless of when they were posted, must output the number of days the challenge has been going at the time of posting. So the first set of answers will output **1**, those posted on the second day **2**, third day **3** etc.

## Restrictions

For the answers posted on the first day, the first set of restrictions are:

* You must include the `0x10` byte in your source code
* You must have an even number of bytes in your source code
* You must only use even bytes in your source code

When you choose your restriction, you may only impose a restriction on the *source code*. This can be as weird as you like (e.g. it must be shaped like unfolded Hexagony code), or a basic as "cannot use this byte", but you may only restrict the source code, rather than e.g. language used. As a general rule, if a challenge including this restriction would be tagged or , it's good to go.

## Scoring

**New answers do not have to follow all of the restrictions.** Instead, they must choose between 1 and all the restrictions to follow. Each answer is worth a number of points equal to the number of restrictions it follows. Your score is the total for all of your answers. Highest score at the end of the challenge wins.

## Ending criteria

The challenge ends when an entire day passes with no new answers, as the restrictions will be updated to nothing.

## Formatting

Please format your answer in the following way:

```
# Day <N>. <Language>, score <X>

    <code>

This follows the restriction(s):

- <restriction 1>
etc.
- <restriction X>

Answers posted tomorrow may use the restriction that <restriction>

---

<Anything else you want to include>

```

## Rules

* You may only post 1 answer per day
* You may only specify 1 restriction in your answer. This restriction may be impossible (as people do not *have* to use it), and may be the same as another answer posted that day. It may also be the same as a restriction from a previous day, but I encourage you to choose more original restrictions over reusing ones.
* Your score only counts *unique* restrictions used. If the same restriction is specified by 3 previous day answers, you may only count it as 1.
* **You may use any language that hasn't been used on a previous day.** You may use a language that has already been used this day, so multiple answers on a specific day can use the same language.
* Byte count has no bearing here, so you are under no obligation to golf your code.
* If restrictions involve specific bytes to be avoided, included etc., you may use any *pre-existing* code page of your choice, so long as it is supported by your language
* You may submit either a full program or a function, so long as it operates under our standard output formats
* Be sure to pay attention to *when* you are posting your answer. If it is posted at 00:00UTC, it is the first answer for the next day, not the last answer for the previous day.
* Times will be measured using SE's time and dating for posts, which can be seen by hovering your mouse over posts which still have "posted X hours ago" or "posted yesterday"
* Different versions of languages, e.g. Python 2 and Python 3 *are* different languages. As a general rule, if the different versions are both available on Try It Online, they are different languages, but keep in mind that this is a general rule and not a rigid answer.
    + Regardless of whether they're both on TIO, minor versions of a language (e.g. Python 3.4 and Python 3.8) are *not* different languages.

Good luck!

---

### Daily scores

| Day | Redwolf Programs | Lyxal | Bubbler | Jonathan Allan | Razetime | tsh | NieDzejkob | Noodle9 | SunnyMoon | pppery | user | PkmnQ | Ramillies | pxeger |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Points | 9 | 3 | 3 | 3 | 3 | 50 | 17 | 2 | 21 | 55 | 6 | 11 | 6 | 16 |
| Answers | 2 | 1 | 1 | 1 | 1 | 21 | 4 | 1 | 6 | 21 | 1 | 2 | 1 | 7 |
| 1 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 2 | 3 | 3 |  |  |  |  |
| 2 | 6 |  |  |  |  | 6 | 5 |  | 7 | 7 | 6 | 5 | 6 |  |
| 3 |  |  |  |  |  |  | 5 |  | 6 | 6 |  | 6 |  |  |
| 4 |  |  |  |  |  | 2 | 4 |  | 2 | 4 |  |  |  |  |
| 5 |  |  |  |  |  |  |  |  | 1 | 2 |  |  |  |  |
| 6 |  |  |  |  |  | 2 |  |  |  |  |  |  |  |  |
| 7 |  |  |  |  |  | 1 |  |  |  | 1 |  |  |  |  |
| 8 |  |  |  |  |  | 2 |  |  |  | 2 |  |  |  |  |
| 9 |  |  |  |  |  |  |  |  | 2 | 2 |  |  |  |  |
| 10 |  |  |  |  |  | 2 |  |  |  | 1 |  |  |  |  |
| 11 |  |  |  |  |  | 2 |  |  |  | 2 |  |  |  |  |
| 12 |  |  |  |  |  | 2 |  |  |  | 2 |  |  |  | 2 |
| 13 |  |  |  |  |  | 3 |  |  |  | 3 |  |  |  |  |
| 14 |  |  |  |  |  | 1 |  |  |  | 1 |  |  |  | 1 |
| 15 |  |  |  |  |  | 3 |  |  |  | 3 |  |  |  | 3 |
| 16 |  |  |  |  |  | 3 |  |  |  | 2 |  |  |  | 3 |
| 17 |  |  |  |  |  | 3 |  |  |  | 3 |  |  |  | 3 |
| 18 |  |  |  |  |  | 2 |  |  |  | 2 |  |  |  |  |
| 19 |  |  |  |  |  | 2 |  |  |  | 2 |  |  |  |  |
| 20 |  |  |  |  |  | 2 |  |  |  |  |  |  |  | 2 |
| 21 |  |  |  |  |  | 2 |  |  |  | 2 |  |  |  | 2 |
| 22 |  |  |  |  |  | 3 |  |  |  | 3 |  |  |  |  |
| 23 |  |  |  |  |  | 2 |  |  |  | 2 |  |  |  |  |
| 24 |  |  |  |  |  | 2 |  |  |  |  |  |  |  |  |

# Answer
> 7 votes
# Day 5, , score 2

```
ANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANANAN

```

(The string `AN` repeated 18724 times.)

Another Unary variant, except this time the reference transpiler actually cares that you type A and silently ignores all other characters. ROT13-ing this replaces each `AN` with a `NA`, which contains the same number of `A`s, so is treated identically. Rotating it by any other number will result in there being no `A`s, and thus make the code do nothing. Satisfied restrictions:

* Your program must still work after being passed through ROT13, and must break after being passed through ROTn, for any n not divisible by 13.
* Answers today may follow half or less of all the other restrictions.

Answers tommorrow may use the restriction that they satisfy at most one restriction from days 1-5.

To be clear, this does include the original restrictions posted in the question body (that applied to day 1 answers), and does include restrictions posted in Day 4 answers, but does not include restrictions posted in Day 5 answers (and thus does not include itself)

# Answer
> 8 votes
# Day 2. JavaScript (V8), score 6

```

e=>(2)//
//[]{}<//
//)2(>=g
//VVVVVVVVV//

```

Try it online!

This follows the restrictions:

* The code uses each of `(){}[]<>` at least once
* It uses a byte which is a prime factor of 420 in its source code (`0x02`)
* The code also performs the task if reversed
* The sum of each byte is a number in the Fibonacci sequence (2584)
* It uses one vowel (`e`)
* It works when `//#` is inserted at the start

Answers posted tomorrow may use the restriction that the program's length is no more than its lowest byte (i.e., a program with a `0x02` byte couldn't be more than two bytes).

# Answer
> 7 votes
# Day 3. Rust, score 5

```
fn/**/main(){print!("3");}//#$%2579?@AABCDEFGHIJKLMNOPQRTUWXYZ^`gjkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx//};)1+ezisu/**/sa)(parwnu.)(tsrif.tupni*-ezisu/**/sa)(parwnu.)(tsal.tupni*==)(nel.tupni(!tressa;)(puded.tupni;)(tros.tupni;))y==x|)y,x(|(lla.))(ver.)(reti.senil(piz.)(reti.senil(!tressa;)(tcelloc.)'n\'b==x|x&|(tilps.tupni=>_<ceV:senil/**/tel};)s=!)(nel.)(>>_<teShsaH<::tcelloc.)s(yb_pets.)(reti.]..i[tupni(!tressa;)s=!)(nel.)(>>_<teShsaH<::tcelloc.)(reti.]s+s*i..s*i[tupni(!tressa{s..0/**/ni/**/i/**/rof;))(nel.tupni==s*s(!tressa;ezisu/**/sa)(trqs.)46f/**/sa)(nel.tupni(=s/**/tel;)(parwnu.)tupni&(8ftu_morf::rts::dts;)(parwnu.)tupni/**/tum&(dne_ot_daer.)(nidts::oi;)(wen::ceV=tupni/**/tum/**/tel{)(niam/**/nf;teShsaH::snoitcelloc::dts/**/esu;}*::edulerp,fles{::oi::dts/**/esu

```

Try it online!

This follows the restrictions:

* Your program, when reversed, must check whether its input is compliant with all the restrictions that your program declares and follows, except for restrictions that are undecidable - Try it online! (errors are reported by panicking)
* Your source code must form a valid UTF-8 stream.
* The bytes of the program, when sorted and duplicates removed, are all consecutive.
* The program is palindromic line-wise (as there's only one line)
* The program has a square number of characters. When formatted in a square grid, each row and column contains at least one duplicated character:

### Restriction for tomorrow

When the bytes of your program are interpreted as a big endian integer, it must be prime:

```
from Crypto.Util.number import *
lambda your_code: isPrime(bytes_to_long(your_code))

```

# Answer
> 6 votes
# Day 1. dotcomma, score 3

```
.,

```

(There are two `0x10` bytes at the end)

Try it online!

This follows the restrictions:

* You must include the 0x10 byte in your source code
* You must have an even number of bytes in your source code
* You must only use even bytes in your source code

Answers posted tomorrow may use the restriction that each byte must be higher than the last (i.e., `20 2a 30 31` would be valid, but not `00 01 00 03`).

# Answer
> 6 votes
# Day 1. Jelly, score 3

```
0‘ḷ“ Ñ

```

Try it online!

The bytes are `[48, 252, 218, 254, 32, 16]` in Jelly code page.

Fulfills these three restrictions:

* You must include the `0x10` byte in your source code
* You must have an even number of bytes in your source code
* You must only use even bytes in your source code

## Tomorrow's restriction

* The code should use each of `(){}[]<>` at least once.

# Answer
> 5 votes
# Day 1. Keg, score 3

```
24<#„22|  „

```

Try it online!

The joys of having a custom code page and a parser that doesn't exactly ignore comments. `2` is less than `4`, so it pushes 1 and autoprints it. The mess after the comment is a string, which the parser tries to parse even though it's in a comment.

This follows all of the day 1 restrictions

## Tomorrow's Restriction

* Byte values must be a multiple of 69.

# Answer
> 5 votes
# Day 2, Lenguage, score 7

Program has a ton of unprintable characters. As a hex dump:

```
00000000  29 28 7b 68 7d 6a 5b 6c  5d 3c 6d 3e 41 00 01 00  |)({h}j[l]<m>A...|
00000010  01 00 01 00 01 00 01 00  01 00 01 00 01 00 01 00  |................|
*
000014f0  01 00 01 00 01 00 01 02  03 02 03 02 03 02 03 02  |................|
00001500  03 02 03 02 03 02 03 02  03 02 03 02 03 02 03 02  |................|
*
00002020

```

8224 bytes of code, equivalent brainfuck `>++.+`, outputting the character with code point 2.

Satisfies these restrictions:

* The code should use each of `(){}[]<>` at least once
* The code also performs the task if reversed.
* You must use any of the following bytes at least once in your code: `0x02, 0x03, 0x05, 0x07` (I use `0x02` and `0x03`)
* The sum of the byte values in your program should be a Fibonacci number (it's 10946, the 21st Fibbonacci number)
* The procedure of repeatedly removing pairs of odd byte, even byte (next to each other; in that order) must remove every byte of your code. That is, if you replaced each odd byte by A and each even byte by B, the sed script :a; s/AB//g; ta must produce no output (code consists purely of alternating odd and even characters)
* You code must include at least one vowel, either uppercase or lowercase i.e. matches /\[aeiouAEIOU\]/
* Your program should work when //# is inserted onto the start of it. (Adding `//#` adds 3 bytes, changing the last `+` in the brainfuck to a `<`, where it still does nothing.)

Answers posted tomorrow may use the restriction that they are pristine.

# Answer
> 4 votes
# Day 1. Jelly, score 3

```
Ñ€PP

```

This follows the restrictions:

* You must include the 0x10 byte in your source code
* You must have an even number of bytes in your source code
* You must only use even bytes in your source code

Answers posted tomorrow may use the restriction that the code also performs the task if reversed.

---

**Try it online!**

The four, even, bytes are `0x10 0x0c 0x50 0x50` (`16 12 80 80`) in Jelly's code-page.

### How?

`0x10` (`Ñ`) is a little hard to use if we cannot use odd bytes, since the newline is a reference to an odd byte, `0x7f` (), while `Ñ` is an instruction to call the next, and hence only, line of source code as a monad. Luckily `0x0c` () is an even byte which, when given an integer will implicitly make a list from one up to that integer before it performs the provided instruction on the each of the list's elements, and a program's implicit input is zero, so  performs no recursive calls. Lastly the product of an empty set is one.

```
Ñ€PP - Main Link: no arguments
 €   - for each (of implicit range of implicit input, 0, = []):
Ñ    -   call the next link (ÑƇPP) as a monad
  P  - product -> 1
   P - product -> 1

```

# Answer
> 4 votes
# Day 1. MAWP, score 3

```
tt:

```

Try it!

There's a `0x10` character at the end.

This follows the restrictions:

* You must include the 0x10 byte in your source code (last char)
* You must have an even number of bytes in your source code (4)
* You must only use even bytes in your source code (`116 116 58 16`)

## Tomorrow's restriction:

You must use a byte which is a prime factor of 420 in your source code. `(2,3,5,7)`. To be more specific, use any of them at least once.

# Answer
> 4 votes
# Day 1, Unary, score 3

```


```

Code consists of 84 `0x10` bytes. Equivalent brainfuck code is `+.`, producing the character with code point 1.

This follows the restrictions:

* You must include the 0x10 byte in your source code
* You must have an even number of bytes in your source code
* You must only use even bytes in your source code.

Answers posted tomorrow may use the restriction that there must be 3 or fewer distinct bytes used.

# Answer
> 4 votes
# Day 2, Free Pascal, score 6

```
begin write(2) end.

 !"#$%&'()*+,-./0123456789:;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
Some more fuzzy texts. So the bytes sum would be a Fibonacci number...
.dne )2(etirw nigeb

```

```
00000000: 0a62 6567 696e 2077 7269 7465 2832 2920  .begin write(2)
00000010: 656e 642e 1a0a 0102 0304 0506 0708 090a  end.............
00000020: 0b0c 0d0e 0f10 1112 1314 1516 1718 191a  ................
00000030: 1b1c 1d1e 1f20 2122 2324 2526 2728 292a  ..... !"#$%&'()*
00000040: 2b2c 2d2e 2f30 3132 3334 3536 3738 393a  +,-./0123456789:
00000050: 3b3c 3d3e 3f40 4142 4344 4546 4748 494a  ;<=>?@ABCDEFGHIJ
00000060: 4b4c 4d4e 4f50 5152 5354 5556 5758 595a  KLMNOPQRSTUVWXYZ
00000070: 5b5c 5d5e 5f60 6162 6364 6566 6768 696a  [\]^_`abcdefghij
00000080: 6b6c 6d6e 6f70 7172 7374 7576 7778 797a  klmnopqrstuvwxyz
00000090: 7b7c 7d7e 0a53 6f6d 6520 6d6f 7265 2066  {|}~.Some more f
000000a0: 757a 7a79 2074 6578 7473 2e20 536f 2074  uzzy texts. So t
000000b0: 6865 2062 7974 6573 2073 756d 2077 6f75  he bytes sum wou
000000c0: 6c64 2062 6520 6120 4669 626f 6e61 6363  ld be a Fibonacc
000000d0: 6920 6e75 6d62 6572 2e2e 2e0a 1a2e 646e  i number......dn
000000e0: 6520 2932 2865 7469 7277 206e 6967 6562  e )2(etirw nigeb
000000f0: 0a                                       .

```
* The code should use each of (){}\[\]\<\> at least once.
* use a byte which is a prime factor of 420 in your source code. (2,3,5,7).
* the code also performs the task if reversed.
* at least one vowel, either upper or lower case
* when //# is inserted onto the start of them
* The sum value of each (unsigned) bytes used in your program should be a number in Fibonacci sequence.

---

Free Pascal compiler just treat the byte `^Z` (`#$1A`) as the end of file. And ignore any following bytes... There is a `^Z` after `end.`. So you may write anything as you like.

---

Day 3:

Your source code as bytes stream should be able to decode as UTF-8.

# Answer
> 4 votes
# Day 2. 99, score 7

<sup>Introducing my newest invention - A great rocket, *uh*, thingy... (Does this even look like a rocket?)</sup>

```
=>=>=>=>=>e
98989 98989 98989
98989 9 98989 9 98989
98989()<{>}~[]lO
98989 9 98989 9 98989
98989 98989 98989
=>=>=>=>=>e

```

Try it online!

This follows the restrictions:

* The code should use each of `(){}[]<>` at least once. \[They are all in the middle of the ship\]
* The code also performs the task if reversed. \[The ship becomes weird though. Try it online!\]
* You must use any of the following bytes at least once in your code: `0x02, 0x03, 0x05, 0x07`\[ represents `0x02`; `0x02` is the heart of the ship :P\]
* The sum of the byte values in your program should be a Fibonacci number \[Adds up to 6765\]
* The procedure of repeatedly removing pairs of odd byte, even byte (next to each other; in that order) must remove every byte of your code. That is, if you replaced each odd byte by `A` and each even byte by `B`, the sed script `:a; s/AB//g; ta` must produce no output \[I have not used sed, but I used 05AB1E to check this rule\]
* You code must include at least one vowel, either uppercase or lowercase i.e. matches `/[aeiouAEIOU]/` \[Uses `e` & `O`\]
* Your program should work when `//#` is inserted onto the start of it. \[99 just ignores that. Try it online!\]

Since my answer is palindromic line-wise, answers posted tomorrow may use the restriction that their programs may be palindromic line-wise :)

---

<sup>Random fact: I spent hours focusing on the aesthetics of the program just to make it look like a spaceship or something.</sup>

# How does a rocket print 2?

Well, rockets in the 99 universe care only about 9's and whitespaces.

Without everything not 9 or not a whitespace, the program looks like this:

```
999 999 999
999 9 999 9 999
999
999 9 999 9 999
999 999 999

```

Read the 99 spec for going in detail with the program. Here is a weird explanation anyway:

```
999 999 999            # Set 999 to 999-999=0
999 9 999 9 999        # Set 999 to 9-0+9-0=18
999                    # Print 999/9 => 2
999 9 999 9 999        # Set 999 to 18 again for in this case no reason
999 999 999            # Set 999 to 0-0=0 again AGAIN for no reason

```

# Answer
> 4 votes
# Day 4, Bubblegum, score 2

Another 1 byte answer. xxd dump as:

```
00000000: 15

```

Try it online!

* deleting characters from the program cannot result in a program in the same language that prints 4 \[Empty program does not print 4\]
* Your code must be at least 50% control characters \[100% Control characters!\]

---

Day 5: Any source code with edit distance 1 to your source code (by inserting 1 byte / deleting 1 byte / replacing 1 byte) should not fit this questions requirement (print 5) in the same language.

# Answer
> 3 votes
# Day 1. Ruby, score 3

```
p 4>>2
""

```

Try it online!

A `\u0010` in quotes.

---

Next day:

The sum value of each (unsigned) bytes used in your program should be a number in Fibonacci sequence. (0, 1, 2, 3, 5, 8, 13, ...)

# Answer
> 3 votes
# Day 2, Scala 3, score 6

```

@main def m=print{2}//S[]<>//(2)tnirp=m fed niam@

```

Try it online!

This follows the restrictions:

* The code uses each of `(){}[]<>` at least once
* It uses a byte which is a prime factor of 420 in its source code (0x07)
* The code also performs the task if reversed
* The sum of each byte is a number in the Fibonacci sequence (4181)
* It uses at least one vowel (a, e, and i)
* It works when `//#` is inserted at the start

Answers posted tomorrow may use the restriction that the bytes of the program, when sorted and duplicates removed, are all consecutive, e.g. `0x03` `0x04` `0x03` `0x02` and `0x00` are valid, but not `0x00` `0x02` `0x03`.

# Answer
> 3 votes
# Day 2. Befunge-98 (PyFunge), score 5

```
\x07$'.269:@krsu{

```

Try it online!

This follows the restrictions:

* Each byte in your answer must be strictly higher than the last (`07 24 27 2e 32 36 39 3a 40 6b 72 73 75 7b`)
* The code also performs the task if reversed - Try it online!
* You must use any of the following bytes at least once in your code: `0x02, 0x03, 0x05, 0x07` (`07` is present)
* The sum of the byte values in your program should be a Fibonacci number (987)
* Your code must include at least one vowel (`u`)

Answers posted tomorrow may use the restriction that your program, when reversed, must check whether its input is compliant with all the restrictions that your program declares and follows, except for restrictions that are undecidable. By Rice's theorem, the decidability condition excludes restrictions that ask about the behavior of the program on an infinite set of inputs, including my restriction.

---

### How does it work?

The `\x07` byte reflects the execution flow, converging with the control flow of the reversed code. `{` creates a new entry on the stack of stacks, to make `u` a valid command and satisfy the vowel restriction. `s` overwrites the next letter (`r`), this pair of bytes is used to increase the byte sum and make a Fibonacci number reachable.

`k` skips over the `@`, then `:96` pushes some garbage onto the stack. `2.` prints the 2. We would now like to reflect off of the `\x07` again to reach the `@`, but we must skip the `.` to avoid printing any garbage. This is accomplished by `'`, which pushes the ASCII value of the next byte instead of executing it, and the `$` to the left is a dummy instruction to be skipped over.

### Additional restrictions considered

I tried to make the `//#` restriction work. `#` would skip the `\x07`, so I had to find a way of composing skips and reflections to achieve what `\x07$'` does now. This conflicted with the strictly-increasing restriction. I also considered not skipping the output command at all, and instead switching to character-based I/O, hoping to output a whitespace character on the second round. I couldn't obtain the necessary ASCII values, though.

Another potential variant was to output and exit at the same time with `q`, but since `2` must be before `q` in the code, a skipping maneuver similar to `@k` would be necessary. There is no suitable byte after `q`, though.

The even/odd repeated removal restriction also cannot be used, as we would need an even byte after `{`, and none are suitable (in general, undefined bytes reflect).

# Answer
> 3 votes
# Day 4, DOS COM file (dosbox), score 4

```
00000000: 8a16 2b01 be0f 01b9 0a00 3014 46e2 fb89  ..+.......0.F...
00000010: 2432 873a fe12 f007 1700 0000 0000 0000  $2.:............
00000020: 0000 2233 3333 3435 3433 3533            .."333454353

```
* programs should contain at least 3 previous programs already submitted to this post (contains 6)
* The bytes of your program interpreted as a big endian integer must be prime
* Your code must be at least 50% control characters (0x00 to 0x1F, 0x7F to 0x9F).
* deleting characters from the program cannot result in a program in the same language that prints 4

Restriction for tomorrow: program must still work after being passed through ROT13, and must break after being passed through ROTn, for any n not divisible by 13.

---

Assembly code:

```
BITS 16
ORG 0x100

    mov dl, [end-1]      ; if any byte is removed, this pointer will break
    mov si, encrypted    ; moreover, any interference early enough will stop
    mov cx, encrypted.end - encrypted  ; the XOR loop from working properly
.decrypt:                ; either way, execution eventually hits an illegal opcode
    xor [si], dl
    inc si
    loop .decrypt

encrypted:
    mov dx, .msg
    mov ah, 9
    int 0x21
    ret
.msg:
    db '4$'
.end:

    times 10 db 0

    db '333454353'
end:

```

Postprocessing script:

```
from Crypto.Util.number import *
with open('gt4.bin', 'rb') as f:
    data = bytearray(f.read())

for i in range(15, 25):
    data[i] ^= data[-1]

for b in range(256):
    data[-10] = b
    if isPrime(bytes_to_long(data)):
        break
else:
    raise hell

control = 0
for byte in data:
    if byte in range(0, 0x20) or byte in range(0x7F, 0xA0):
        control += 1

print(control / len(data))

with open('gt4.com', 'wb') as f:
    f.write(data)

```

# Answer
> 3 votes
# Day 4. !@#$%^&\*()\_+, score 2

```
333454333@

```

Try it online!

Prints an end of transmission, as it is allowed to output characters instead of integers.

This follows the following restrictions:

* programs should contain at least 3 previous programs already submitted to this post \[`333454353` altogether contains 6 programs: 5 `3`'s and 1 `333454353`\]
* Your code must be at least 50% control characters (0x00 to 0x1F, 0x7F to 0x9F). \[10 Control codes, 10 other\]

Answers tommorow may follow half or less of all the other restrictions. (as I did, :P)

---

# Answer
> 3 votes
# Day 9, ///, score 2

```
9

```

Try it online!

This is what happens if all restrictions prohibit you from doing something and none require you to.

Satisfies both restrictions:

* Programs must include no characters that are used in day 8 answers.
* Your source code should not contain duplicate bytes. That is to say, your source code should not contain two bytes which have the same byte value.

Answers tommorrow may use the restriction that their source code is only 1 byte long.

# Answer
> 3 votes
# Day 13, Python 2, score 3

```
x="))]]]]}}}}}}}}bdfhjlnprt";print(ord(x[24])/2)

```

Note the unprintable character with codepoint 26 between `prt` and `"`" (it's in the TIO link)

Satisfies all 3 restrictions.

Deleting any parenthesis will break the code by making the string less than 24 characters wrong, making `x[24]` be an `IndexError`

Deleting even characters is more difficult to analyze.

1. The `x` can't be deleted because no valid Python program starts with `=`.
2. The first `"` can't be deleted because the `)` character will become unmatched and throw an invalid syntax error.
3. Deleting characters in the string will break the indexing and cause a `IndexError`
4. Deleting the second `"` causes the first `"` to be unmatched.
5. Deleting any of the characters in `print` will result in there being no code to print anything, and thus no output. (`x="))]]]]}}}}}}}}bdfhjlnprt";int(ord(x[24])/2)` is syntactically valid code that does nothing).
6. Deleting the `o` in ord will cause a `NameError` since `rd` isn't defined.
7. Deleting the `2` or `4` in `x[24]` produces `x[2]` or `x[4]`, which index into the parens start of the string.

Answers tomorrow may use the restriction that the average of the bytes is greater than 100.

Try it online!

# Answer
> 2 votes
# Day 1. Z80Golf, score 3

```
00000000: 3e30 3cc4 1076 7676                      >0<..vvv

```

Try it online!

This follows the restrictions:

* You must include the 0x10 byte in your source code
* You must have an even number of bytes in your source code
* You must only use even bytes in your source code

Answers posted tomorrow may use the restriction that the procedure of repeatedly removing pairs of `odd byte, even byte` (next to each other; in that order) must remove every byte of your input. That is, if you replaced each odd byte by `A` and each even byte by `B`, the sed script `:a; s/AB//g; ta` must produce no output.

---

Disassembled:

```
ld a, $30
inc a
call nz, $7610
halt
halt

```

# Answer
> 2 votes
# Day 1 Python 3, score 2

```
print(len(' '))

```

Try it online!

Hexdump:

```
> hexdump -C quickly_group_together_day1.py
00000000  70 72 69 6e 74 28 6c 65  6e 28 27 10 27 29 29 0a  |print(len('.')).|
00000010

```

This follows the restrictions:

* You must include the 0x10 byte in your source code **Note** the quoted character in my hexdump is `0x10`, couldn't figure out a way to get that into TIO
* You must have an even number of bytes in your source code **Note** there is a trailing `0x0a` character to even out the byte count to \\$16\\$
* ~~You must only use even bytes in your source code~~ Couldn't figure out a way to follow this in any version of Python.

Answers posted tomorrow may use the restriction that it uses at least one vowel, either upper or lower case, i.e. matches `/[aeiouAEIOU]/`.

# Answer
> 2 votes
# Day 1. 05AB1E, score 3

```
X

```

This follows the restrictions:

* You must include the 0x10 byte \[data link escape\] in your source code \[It is at the end\]
* You must have an even number of bytes in your source code \[The number of bytes is 2\]
* You must only use even bytes in your source code \[X: 88, DLE: 16\]

Answers posted tomorrow may use programs that work when `//#` is inserted onto the start of them.

---

Uses the actual UTF-8 encoding.

Try it online!

## How?

```
X                 # Push 1 (Coding 1 would not work because it has an odd codepoint: 49)
                 # Do literally nothing
                  # Print 1!

```

# Answer
> 2 votes
# Day 2. Actually, score 5

```
♥►F

```

Try it online!

The bytes are `[0x03, 0x10, 0x46]`.

This follows the restrictions:

* Each byte in your answer must be strictly higher than the last.
* You must use any of the following bytes at least once in your code: 0x02, 0x03, 0x05, 0x07 (Uses `0x03`.)
* The sum of the byte values in your program should be a Fibonacci number. (Bytes sum to 89.)
* Your program should work when `//#` is inserted onto the start of it. (Check here.)
* There must be 3 or fewer distinct bytes used in your program.

---

Restriction: The output does not change when `/*` is added to the beginning.

# Answer
> 2 votes
# Day 2, Raku (Perl 6), score 6

```
#
{+ords(<^C^E>[*])}#1d1d1d1f2#tnirp.2

```

*Here `^C` stands for `0x03` and `^E` for `0x05`.*

## Satisfied restrictions

* The code should use each of `(){}[]<>` at least once
* The code also performs the task if reversed.
* You must use any of the following bytes at least once in your code: `0x02, 0x03, 0x05, 0x07` (*0x03 and 0x05 are used.*)
* The sum of the byte values in your program should be a Fibonacci number (*The sum is 2584 = F<sub>18</sub>*.)
* The procedure of repeatedly removing pairs of odd byte, even byte (next to each other; in that order) must remove every byte of your code. That is, if you replaced each odd byte by `A` and each even byte by `B`, the sed script `:a; s/AB//g; ta` must produce no output
* You code must include at least one vowel, either uppercase or lowercase i.e. matches `/[aeiouAEIOU]/`.

## A bit of explanation

`<^C^E>` is a string of 2 bytes `"\x03\x05"`. We take everything of it `[*]`, take ASCII numbers with `ords` and then get the length of the list, which is 2. That is returned.

If reversed, it gives `2.print`, which just prints 2.

The first line is an artifact of me trying to satisfy the `//#` restriction. When I realized that no Raku program can ever satisfy this (`//` does not mean anything by itself), deleting it would destroy the Fibonacci restriction, so it's going to stay there.

## Restriction for tomorrow

Your program has exactly \\$N^2\\$ characters (for some integer \\$N\>0\\$). If you write it into a table of \\$N×N\\$ cells (start at the top left and write 1 character per cell from left to right and then top to bottom), there must be at least one repeated character in each row and each column. (E. g. `AACABBCBB` is a valid string as it forms the table

```
AAC
ABB
CBB

```

and each row and each column contains a repeated character.)

*(Perhaps it can be formulated in a better way. Let me know if you find how.)*

# Answer
> 2 votes
# Day 3, brainfuck, score 6

```
...------

```

Outputs three null bytes (3 in unary).

Try it online!

Satisifed restrictions:

* The program's length is no more than its lowest byte (length is 9, lowest byte is 45)
* The bytes of the program, when sorted and duplicates removed, are all consecutive (there are only two bytes, `.` (45) and `-` (46)).
* The output does not change when `/*` is added to the beginning. (brainfuck ignores both of those characters)
* The program has a square number of characters. When formatted in a square grid, each row and column contains at least one duplicated character. As a grid:
```
...
---
---

```
* The program is palindromic line-wise (trivially satisfied because there is only one line)
* Your source code must form a valid UTF-8 stream.

Answers tomorrow may use the restriction that deleting characters from the program cannot result in a program in the same language that prints `4` (or, in other words, no adding useless fluff to your code to satisfy other restrictions).

Today is a boring day, because satisfying 6 restrictions is really easy, and satisfying 7 or more is really hard, maybe impossible.

# Answer
> 2 votes
# Day 3, Trigger, score 6

```
333454353

```

Try it online!

## Restrictions used

* The program's length is no more than its lowest byte (Lowest byte is `51`.)
* The bytes of the program, when sorted and duplicates removed, are all consecutive. (`3`, `4`, `5`.)
* The output does not change when `/*` is added to the beginning. (We only print `3` and flip some triggers, of course this works.)
* The program has a square number of characters. When formatted in a square grid, each row and column contains at least one duplicated character.
```
333
454
353

```
* The program is palindromic line-wise. (There's only one line.)
* Your source code must form a valid UTF-8 stream. (`3`, `4`, and `5` are valid UTF-8.)

## Restriction for tomorrow

Your code must be at least 50% control characters (`0x00 to 0x1F`, `0x7F to 0x9F`).

# Answer
> 2 votes
# Day 4, Ellipsis, score ~~3~~ 4

Effectively rewritten from scratch after several restrictions were changed in ways that contradicted my original interpretation of them.

Another really long code full of unprintables in a Unary variant. As a hexdump:

```
00000000  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00001b60  00 00 00 00 00 00 00 00  33 33 33 19              |........333.|
00001b6c

```

That is, 7016 null bytes, followed by 3 `3` characters (thereby satisying the different programs restriction), followed by the byte with codepoint 25 (to satisfy the prime restriction). Equivalent Brainfuck code is `....`.

The specification for Ellipsis says dots or Unicode ellipsis characters are mandatory, but the reference Ruby implementation cares only about the length, and languages are defined by their implementation on CGCC, so this is allowed.

Satisfied restrictions:

* programs should contain at least 3 previous programs already submitted to this post (question)!
* deleting characters from the program cannot result in a program in the same language that prints 4
* Your code must be at least 50% control characters (0x00 to 0x1F, 0x7F to 0x9F).
* The bytes of your program interpreted as a big endian integer must be prime.

Answers tomorrow may use the restriction that they satisfy more than half of the restrictions for any past day.

# Answer
> 2 votes
# Day 6, V (vim), score 2

```
C5esckk^Aenter#255

```

Try it online!

* Your program should not contain 6 (#54) or any acknowledgment (#06).
* Your program satisfies at most one restriction from days 1-*4*.
    + Answers in day 5 may follow half or less of all the other restrictions.

---

Tomorrow:

Answer should not be an empty program and may only use bytes in range 128~255.

# Answer
> 2 votes
# Day 7, なでしこ3, score 1

```
「文文文文文文字」で「字」を文字検索を表示

```

Copy-paste above codes to this online test page and hit the `▶ 実行` button.

* Your answer should not be an empty program and may only use bytes in range 128 to 255

I know nothing about this language before. When I wrote the requirement yesterday, I didn't take it too seriously. And didn't considered it could ever be done. But since someone had posted an answer today. I would just want to find out one...

I cannot understand the document of this language as they are all written in Japanese. To my (poor) understanding (based on kanji in it): `表示` means `print(...)`, `文字検索` is `String indexOf`. So it is basiclly `print("文文文文文文字".indexOf("字"))`. And it seems to be 1-indexed while I don't know why.

---

So, next day:

When reverse your program, it should print -8 (as in day 8).

# Answer
> 2 votes
# Day 8, str, score 2

```
7ne:8o;o_8

```

Try it online!

Satisfies both restrictions:

Answers tommorrow may use the restriction that they include no characters that are used in this answer or other day 8 answers.

# Answer
> 2 votes
# Day 8, JShell, score 2

```
//:Rxrsdl-nts-oqhmskm'7(:.dwhs
System.out.println(8);/exit
tixe/;)8-(nltnirp.tuo.metsyS;00

```

xxd:

```
00000000: 2f2f 3a52 7872 7364 6c2d 6e74 732d 6f71  //:Rxrsdl-nts-oq
00000010: 686d 736b 6d27 3728 3a2e 6477 6873 090a  hmskm'7(:.dwhs..
00000020: 5379 7374 656d 2e6f 7574 2e70 7269 6e74  System.out.print
00000030: 6c6e 2838 293b 2f65 7869 740a 7469 7865  ln(8);/exit.tixe
00000040: 2f3b 2938 2d28 6e6c 746e 6972 702e 7475  /;)8-(nltnirp.tu
00000050: 6f2e 6d65 7473 7953 3b30 300a            o.metsyS;00.

```

As it's day 8, no body had posted Java codes on this thread yet...

Seems TIO didn't include this language... You can test it by: Save above xxd as `some_file`, and execute

```
xxd some_file > some.jsh
jshell some.jsh

```

I'm using `java 11.0.8 2020-07-14 LTS` in case it matters.

* The program also produces the correct value if you increase every byte by one.
* When reverse your program, it should print -8 (as in day 8).

Plus by one:

```
00000000: 3030 3b53 7973 7465 6d2e 6f75 742e 7072  00;System.out.pr
00000010: 696e 746c 6e28 3829 3b2f 6578 6974 0a0b  intln(8);/exit..
00000020: 547a 7475 666e 2f70 7675 2f71 736a 6f75  Tztufn/pvu/qsjou
00000030: 6d6f 2939 2a3c 3066 796a 750b 756a 7966  mo)9*<0fyju.ujyf
00000040: 303c 2a39 2e29 6f6d 756f 6a73 712f 7576  0<*9.)omuojsq/uv
00000050: 702f 6e66 7574 7a54 3c31 310b            p/nfutzT<11.

```

Reversed:

```
00000000: 0a30 303b 5379 7374 656d 2e6f 7574 2e70  .00;System.out.p
00000010: 7269 6e74 6c6e 282d 3829 3b2f 6578 6974  rintln(-8);/exit
00000020: 0a74 6978 652f 3b29 3828 6e6c 746e 6972  .tixe/;)8(nltnir
00000030: 702e 7475 6f2e 6d65 7473 7953 0a09 7368  p.tuo.metsyS..sh
00000040: 7764 2e3a 2837 276d 6b73 6d68 716f 2d73  wd.:(7'mksmhqo-s
00000050: 746e 2d6c 6473 7278 523a 2f2f            tn-ldsrxR://

```

---

Tomorrow: Your source code should not contain duplicate bytes. That is to say, your source code should not contain two bytes which have the same byte value.

# Answer
> 2 votes
# Day 12, Yabasic, score 2

```
print--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------6+6

```

Try it online!

* may still work by deleting exactly 2 nonconsecutive bytes
    + delete any two `-` works
* exactly 1024 bytes long and break if any single byte is removed
    + Remove any character in `print` doesn't yield output
    + Remove any `-`, `+`, or `6` yield wrong output

---

Tomorrow: Your program should contain at least 2 more `)` than `(`, 4 more `]` than `[`, 8 more `}` than `{`. When any number of character `)`, `]`, `}` removed, your program doesn't work.

# Answer
> 2 votes
# Day 13, C# (.NET Core), score 3

```
using　System;class　P{static　void　Main(){var　A="))]]]]}}}}}}}}0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";if(A.Length==117)Console.Write(A.Length/9);}}

```

Try it online!

There isn't a C# answer yet...

* contain no ASCII spaces or line feeds. (All spaces are full-width ones )
* more even bytes than odd bytes and breaks if any number of even bytes are deleted
* contain at least 2 more ) than (, 4 more \] than \[, 8 more } than {. When any number of character ), \], } removed, your program doesn't work.

---

Tomorrow: The sum of each bytes of your source code is a non-zero value which equals to the product of each bytes.

Let's say your source code contains \\$n\\$ bytes (\\$n\neq0\\$), whose byte value is \\$b\_0,b\_1,\dots,b\_{n-1}\\$:

$$\sum\_{i=0}^{n-1}b\_i=\prod\_{i=0}^{n-1}b\_i\neq0$$

# Answer
> 2 votes
# Day 14, Wikitext, score 1

```
{{echo|14}}

```

Byte average is \\$103 \frac{2}{9}\\$

Answers tomorrow may use the restriction that they do not contain any characters used in Day 14 answers.

# Answer
> 2 votes
# Day 19, calc (TTK), score 2

```
023 #Tip

```

Try it online!

* at least 8 char long, Both upper, lower, number and other chars TIO
* each byte has its position as factor TIO

Many languages use a single `#` as start of line-wise comment. And a `#` has ASCII value 35. So all you need is to find some expression works in 4 or 6 bytes.

So following JavaScript code suggest `023`  or `023 -0` would work:

```
charset = '+-*/0123456789 '

function search(l = 0, prefix='') {
  if (prefix.length === l) {
    try {
      const r = eval(prefix);
      if (r === 19) {
        print(prefix);
      }
    } catch (e) {}
  } else {
    const pos = prefix.length + 1;
    [...charset].forEach(ch => {
      if (ch.charCodeAt() % pos !== 0) return;
      search(l, prefix + ch);
    });
  }
}

search(4)
search(6)

```

Try it online!

So maybe any language that:

* Support `0` start number as octal
* Support `#` as comment
* Print the value by default, or maybe by symbols like `@`

should work.

---

Tomorrow: A space has code point `U+0020`. So, next day... Your source code, when decode as extended ASCII, should contain at least one whitespace character. When any whitespace character is removed or replaced by any other non-whitespace character, your program should *fail* to print 20. (Whitespace are defined as one of ASCII characters \[32, 9, 10, 11, 12, 13\].)

# Answer
> 2 votes
# Day 24, ABC, score 2(?)

```
IF	 1<3:
	PUT	 'BAB'|	0	 IN	 aba
IF	 1<3:
	PUT	 'BAB'|	0	 IN	 cbc
IF	NOT	(aba<cbc OR	 cbc<aba ):
	PUT	 aba IN	 ebe
IF	 1<3:
	PUT	 '2'^'4' IN	 gdg
IF	 1<3:
	PUT	 '2'^'4' IN	 idi
IF	NOT	(gdg<idi OR	 idi<gdg ):
	PUT	 gdg IN	 kdk
WRITE ebe^kdk

```

Try it online!

* Bytes are odd, even, odd even, odd, even
* Edit distance 1 print 24 or fail to print number (Not sure if it works...)

I'm not sure if the edit distance restriction works. But it seems to be:

* Make any if condition false skip variable declaration. And the program won't run.
* Change value of `aba`, `cbc`, `ada`, `cdc` cause the equal check fail.
* The most terrible line is the last one:
    + Anyway, break `WRITE` simply break writing
    + Break variable name cause undefined variable error
    + Remove `^` cause undefined variable error
    + Change `^` to other single character operator, they won't work on two string
    + change `^` to `^^`, it won't work on two string
    + comment out `^kdk` print nothing
    + Insert `#` convert a operand of `^` to integer and fail

First, I want declare two variables as 24. Check if they are equal and then print one of them. Since I cannot use `main`, nor `print`, `io`, `echo`, `out`. But `puts` and `write` are available. Then go to language list to find a language use `write` or `puts`. Tcl works but it require `set` to define a variable. After that, I noticed that ABC work, as `put` and `in` are all valid words in such restriction...

Also

* Write an integer won't work: inserting `-` will still yield valid output
* Write a string won't work too: `#` may be inserted which is an operator calculates length of string
* When write a expression, be careful it may not print numbers when `\` is inserted (`\` is the starting of line wise comment.)
* Variables may not be single byte. Or it is easy to edit.

---

Tomorrow: Exist a number n (n \>= 1), your each bytes mod n result a continuously increasing sequence.

Let's say your program contains \\$ k \\$ bytes \\$ b\_1 \dots b\_k \\$. Then \\$ \exists n \in \mathbb{N}^+ : \forall i=1\dots k-1 : b\_{i+1} \mod n = \left(b\_{i} \mod n\right) + 1 \\$.

# Answer
> 1 votes
# Day 3, Seriously, score 6

```
3

```

Try it online!

Just a copy of tsh's answer which follows the exact same restrictions:

* The bytes of the program, when sorted and duplicates removed, are all consecutive \[There is one lonely byte\]
* Programs must be pristine \[Well, there is one byte only, so...\]
* The program is palindromic line-wise \[My restriction is 2 ez for everyone\]
* The program's length \[1\] is no more than its lowest byte \[51\]
* The output does not change when `/*` is added to the beginning. \[Thank goodness it ***Actually***<sub>Find the pun</sub> works\]
* The source code is valid UTF-8 stream. (I honestly do not know what this means, but it is followed by tsh's answer)

Since I copied my answer, day 4 programs should contain at least 3 previous programs already submitted to this post (question)!

---

I *also* know nothing about this language. tsh's hypothesis is correct!

# Answer
> 1 votes
# Day 5. CJam, score ~~2~~ 1

```
4)

```

Try it online!

This satisfies the restrictions:

* ~~Any source code with an edit distance of 1 to your source code (by inserting 1 byte / deleting 1 byte / replacing 1 byte) should not fit this question's requirement (print 5) in the same language. \[I could not find any program with an edit distance of one with `4)`\]~~ Apparently my program does not follow this restriction. (I still do not have an idea why)
* Answers today may follow half or less of all the other restrictions. \[( ͡° ͜ʖ ͡°) \<Insert boss music here\>\]

Tomorrow, answers should not contain `6` (`0x54`) or any acknowledgment (`0x06`).

---

<sup>To satisfy the edit distance restriction, I typed a random key. It turned out to be the closing parenthesis, which apparently in CJam is the increment operator! (I have never touched this language before)</sup>

# Answer
> 1 votes
# Day 7, Glypho, score 1

```
ââäàââäàââäàââäàââäàââäàââäàâääââääââääââääââääââääââäää

```

Try it online!

Sorry, I should have posted an answer to this challenge yesterday, but I forgot. I'm back now, though. This follows the only restriction:

* Your answer should not be an empty program and may only use bytes in range 128 to 255

Answers tommorrow may use the restriction that the program also produces the correct value if you increase every byte by one.

# Answer
> 1 votes
# Day 9, MathGolf, score 2

```
9

```

Try it online!

Satisfies all the restrictions :D

* Programs must include no characters that are used in day 8 answers. \[Nobody uses `9` :(\]
* Your source code should not contain duplicate bytes. That is to say, your source code should not contain two bytes which have the same byte value. \[There is only one byte\]

The restriction for tommorrow is that programs should only use characters that are alphanumeric.

---

Here is a meme for anyone interested:

# Answer
> 1 votes
# Day 10, Jolf, score 2

```
t

```
* programs should only use characters that are alphanumeric
* source code is only 1 byte long

Try it

Wow! I finally find out this!

Tomorrow:

Your source code does not contains any bytes in range 48~57, 65~70, 97~102. (`0-9A-Fa-f`).

# Answer
> 1 votes
# Day 10, \>\<\>, score 1

```
ann

```

Try it online!

Satisfies only the alphanumeric restriction.

Answers tommorrow may use the restriction that they contain an odd number of odd bytes and a nonzero even number of even bytes.

# Answer
> 1 votes
# Day 11, Excel, score 2

```
=NOT(G:G)+NOT(G:G)+NOT(G:G)+NOT(G:G)+NOT(G:G)+NOT(G:G)+NOT(G:G)+NOT(G:G)+NOT(G:G)+NOT(G:G)+NOT(G:G)

```
* contain an odd number (55) of odd bytes and a nonzero even number (44) of even bytes
* does not contains any bytes in range 48~57, 65~70, 97~102

Today is an easy day.

---

Tomorrow: Your source code is exactly 1024 bytes long. And the program will not work as this question required if any single byte is removed from your source code.

# Answer
> 1 votes
# Day 11, Morsefuck, score 2

```
.-..-..-..-..-..-..-..-..-..-..-.

```

Contains 22 `.` (codepoint 46) and 11 `-` (codepoint 45) characters. Equivalent brainfuck: `...........`.

Satisfies both restrictions.

Answers tomorrow may use the restriction that it is possible to produce a valid answer by deleting exactly 2 nonconsecutive bytes.

# Answer
> 1 votes
# Day 12, Minkolang, score 2

```
############################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################v
############################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################>93+N.

```

Satisfies both restrictions (Removing any of the `#` or the newline disconnects the `v` from the `>`, causing the code to infinite loop. Removing the `v`, the `>` or the `.` likewise causes an infinite loop. Removing any other characters changes the output. You can, however, remove two `#` characters without changing the result)

Answers tomorrow may use the restriction that the code contains more even bytes than odd bytes and breaks if any number of even bytes are deleted.

Try it online!

# Answer
> 1 votes
# Day 12, ksh, score 2

```
print 12''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

```

Try it online!

Satisfies both criteria:

* removing any single character breaks the program (breaks `print`, prints the wrong number, or quotes become unbalanced)
* removing any two non-consecutive single-quotes does not break the program

New criterion for tomorrow:

> Your program must contain no ASCII spaces or line feeds.

# Answer
> 1 votes
# Day 14, Make, score 1

```
$(info 14)#平均

```

Try it online!

* Byte average = 107.5 \> 100

After quite a lot of searching, I got 4 languages may output `14` for source code `E`. But none of theme works for `e`. So I had to give up a score 2 answer. After that, it could be very easy since you just need to pad some more bytes for an average value greater than 100.

---

Tomorrow:

Your source code is at least 2 bytes long and the standard deviation of bytes in your source code should be greater than 50.

Suppose your source code contains \\$n\\$ bytes \\$b\_1...b\_{n}\\$ (\\$n\>1\\$). Standard deviation \\$\sigma\\$ is defined as

$$ \sigma = \sqrt{\frac{1}{n-1}\sum\_i(b\_i-\bar{b})^2} $$

$$ \bar{b} = \frac{\sum\_i b\_i}{n} $$

You can calculate it using following Python 3 code snippet:

```
import numpy as np

source_code = b'print(15)'
print(np.std(list(source_code)))

```

Try it online!

(In case I have any typo in the formula, follow the Python code.)

# Answer
> 1 votes
# Day 14, TypeScript, score 1

```
console.log(~~~~~~~~14)

```

Try it online!

Byte average is \\$\approx100.565\\$.

Restriction for tomorrow:

> Your code must still work when a certain character (of your choosing) is inserted at any point in the program. E.g. if your program is `abc` and you choose `:`, then all of `abc`, `:abc`, `a:bc`, `ab:c`, and `abc:` must work.

# Answer
> 1 votes
# Day 15, Tir, score 3

```
7 8+zzzzzz

```

Try it online!

Notice that 3 null bytes at the end of source code.

* standard deviation of bytes = 50.77 \> 50
* work when space () is inserted at any point in the program
* do not contain any characters used in Day 14

Just search the TIO and finally find out one.

---

Tomorrow:

Consider any sub-sequence bytes of your source code: There are exactly 15 (original source code not included in these 15 sub-sequence) sub-sequence work as this question required (print 16).

For example, your source code is `ABCDE` then , `A`, `B`, `AB`, `C`, `AC`, `BC`, `ABC`, `D`, `AD`, `BD`, `ABD`, `CD`, `ACD`, `BCD`, `ABCD`, `E`, `AE`, `BE`, `ABE`, `CE`, `ACE`, `BCE`, `ABCE`, `DE`, `ADE`, `BDE`, `ABDE`, `CDE`, `ACDE`, `BCDE`, are sub-sequence of your source code. And there should be exactly 15 of them work.

Another example, suppose your source code is `ABABCDE`. `ABCDE` is 1 sub-sequence of your source code. And `ABCDE` should not be count as 3 sub-sequences.

# Answer
> 1 votes
# Day 15, Unibrain, score 3

```
zzz zzz zzz zzz zzz zzz zzz zzz zzz zzz zzz zzz zzz zzz zzz zzzzz

```

The character between each set of `zzz`s is a tab character, and there are four trailing tabs.

Satisfies all three restrictions:

* standard deviation of bytes = 50.47 \> 50
* works when tilde (`~`) (or any other non-whitespace, non-alphanumeric character) is inserted at any point in the program
* does not contain any characters used in Day 14.

Answers tommorrow may use the restriction that, for every number between 1 and 15 inclusive, there must be a subsequence of the program that prints that number.

# Answer
> 1 votes
# Day 15, emotifuck, score 3

```
!!!!!!

```

Emotifuck is a trivial brainfuck substitution. The normal version is:

```
+++++++[>+++++++<-]>.++++.!!!!!!

```

Multiply 7 by 7 to get ASCII 1 (decimal codepoint 49), print, add 4, and print.

The exclamation marks do nothing except ensure that

* The standard deviation of the bytes is \\$\approx50.507\\$

Also

* Works if any non-emoji character is inserted anywhere in the program.
* Does not contain any characters used on Day 14.

Try it online!

Restriction for tomorrow:

> The program must include at least one character\* from every previous answer to this challenge (up to and including day 15)
>
> <sub>\*some languages (e.g. Bubblegum) do not have an encoding with characters. In this case, you can ignore that answer.</sub>

# Answer
> 1 votes
# Day 16, CoffeeScript 1, score 3

```
ä=console;文="NPFX!=0.29134 nt";ä.log(文.length)###############

```

Try it online!

I hope this works....

* include at least one character from every previous answer
    + This does not include the answer in Bubblegum and Unary (to my understand)
* subsequences for each number between 1 and 15 inclusive
    + Just remove some character in the string
* 15 subsequences works
    + Only `#` may be removed. And there are 15 `#`s
    + Remove part of multi-byte characters cause invalid variable
    + Remove anything in the string make it result incorrectly
    + Remove any part of `console` or `log` break the output
    + Remove part or whole `.length` make it print other values
    + Remove others may also cause syntax errors

Some one posted a TypeScript answer a few days ago. And I realized that I can post another CoffeeScript answer. Another variance of JavaScript.

---

Tomorrow: Your source code contains at least 2 non-empty lines. The byte sum of each line (excluding line breaks) should be equal. But any two line should not share same characters. A trailing empty new line may be allowed in your source code which didn't count as a line in this restriction.

# Answer
> 1 votes
# Day 16, FuckbeEs, score 2

```
bbbbbbbbbbbbbbbbccccccccccccccc

```

Try it online!

Satisfied restrictions:

* Subsequences for each number between 1 and 15 inclusive
    + This program outputs in Unary, with each `b` contributing 1 character. Removing a `b` results in 15, 2 `b`s results in 14, and so on.
* 15 subsequences works
    + Removing `c`s at the end does nothing. This satisfies the restriction in the same way as the 15 `#` in tsh's answer.

Answers tommorrow may use the restriction that the number of bytes they have is a power of 17.

# Answer
> 1 votes
# Day 16, Elixir, score 3

```
s='!nz})~9」5äA3FXP0';IO.puts length s###############

```

Try it online!

More or less a direct port of @tsh's answer.

---

Restriction for tomorrow:

> Answers may not be valid UTF-8, as understood by Python 3.9's `bytes.decode` with `errors="strict"`

# Answer
> 1 votes
# Day 17, Windows CMD, score 3

```
@echo 17
::?AAAPP

```

xxd:

```
00000000: 4065 6368 6f20 3137 0a3a 3aff 4141 4150  @echo 17.::.AAAP
00000010: 50                                       P

```

The `?` is for `\xff` as what I did in the vim answer.

* invalid UTF-8 (`\xff`)
* 17<sup>1</sup> bytes
* same byte sum each line, no dupe char between lines

Sounds quite easy today.

---

To make it more complex tomorrow:

Your source code contains multiple lines. No duplicate characters between lines. No empty lines. The bytes' product (multiplication) of each line should be equal. A trailing empty new line may allowed in your answer which doesn't count a line to this question. Line breaks does not belong to any line as in this restriction.

# Answer
> 1 votes
# Day 17, ;#+, score 3

```
;;;;~++++;
p8899ÿ

```

Satisfies all 3 restrictions:

* invalid UTF-8 (the `ÿ` at the end is a `\xff` byte)
* 17<sup>1</sup> bytes
* same byte sum (538) each line, no dupe char between lines

Answers tomorrow may use the restriction that there are no bytes less than or equal to 5.

Try it online!

# Answer
> 1 votes
# Day 17, Python 1, score 3

```
print 17
#||4!!%ÿ

```

Try it online!

`ÿ` is a `0xFF` byte. (I don't know how to get invalid UTF-8 into TIO or StackExchange, so I put in the character with Unicode codepoint `0xFF` instead)

---

Restriction for tomorrow:

> Your program must by a polyglot in Markdown, so that when rendered to HTML by StackExchange's parser, it **looks like** the following; the parts in italics are placeholders which you can replace with any non-empty unformatted text. The links must be clickable but do not necessarily have to lead anywhere.
>
> ---
>
> > # Day 18, *SOME LANGUAGE*, score *N*
> >
> > ```
> > *SOME CODE*
> >
> > ```
> >
> > Try it online!
> >
> > *EXPLANATION PARAGRAPH*
> >
> > ---
> >
> > Restriction for tomorrow:
> >
> > > *EXPLANATION PARAGRAPH 2*

I hope this is clear enough, now go and read up on Markdown's various alternative syntaxes! Style points if you can make it exactly the same text as your post.

# Answer
> 1 votes
# Day 18, Emoji, score 2

```
# Day 18, [Emoji], score 2

    18➡

[Try it online!][TIO-kivh57t8]

[Emoji]: https://esolangs.org/wiki/Emoji
[TIO-kivh57t8]: https://tio.run/##S83Nz8r8///D/ElrDC1A5KN5C///BwA "Emoji – Try It Online"

I cannot make this markdown render works with milti-line codes while not sharing characters between lines. So I think it is impossible to get a score 3.

> Restriction for tomorrow:
Your source code should be valid UTF-8 stream. And when decode as UTF-8, it is at least 8 characters long and contains at least one uppercase letter, one lowercase letter, one numeric character, and one character not belongs to any above sections. For more details, it could be defined as [this Python code](https://tio.run/##XY4/CsIwGMX3nuKjUwLFxUUK9SLiENMUA2kS0hTpqDfQraPQwTNIexoH3XKEWPrHguP73u997@nKHpVce1@o0lAGCYSubVx3dl3t2qtr69fl9rk/3s0zDAJKbE/sCmtWvCi1ZiaCUQh1WoQsc2Y43QdUSUu47DOC5IeUwNgSzzKLgcgK5USjLJpMjANtuLRIMImmE2wT2PRoCkSIAZ8@z0AE/TSMB@TPQlMXjUEq@@tbFmSIznmMvf8C).

```

Try it online!

I cannot make this markdown render works with milti-line codes while not sharing characters between lines. So I think it is impossible to get a score 3.

---

Tomorrow: Your source code should be valid UTF-8 stream. And when decode as UTF-8, it is at least 8 characters long and contains at least one uppercase letter, one lowercase letter, one numeric character, and one character not belongs to any above sections. For more details, it could be defined as this Python code.

# Answer
> 1 votes
# Day 18, Foo, score 2

```
# Day 18, [Foo], score 2

    "18"

Satisfies the markdown polyglot and the no bytes less than or equal to 5 restrictions.

[Try it online!][TIO-kivtlq6s]

Restriction for tomorrow:
> Every byte must have it's index in the program as a factor (the first byte can be anything, the second byte must be divisible by two, the third byte must be divisible by three, and so on).

[Foo]: https://esolangs.org/wiki/Foo
[TIO-kivtlq6s]: https://tio.run/##S8vP//9fydBC6f9/AA

```

Satisfies the markdown polyglot and the no bytes less than or equal to 5 restrictions.

Try it online!

Restriction for tomorrow:

> Every byte must have it's index in the program as a factor (the first byte can be anything, the second byte must be divisible by two, the third byte must be divisible by three, and so on).

# Answer
> 1 votes
# Day 19, Emmental, score 2

```
#rA1
9.

```

Try it online!

There are a ton of unprintables, see the TIO link for the full code. Yay programming languages that ignore unrecognized characters!

Satisfies both restrictions.

Answers tomorrow may use the restriction that all bytes must be distinct.

# Answer
> 1 votes
# Day 20, Bash, score 2

```
echo 20

```

Try it online!

Today is easy....

* all bytes distinct
* contain whitespace which cannot be removed nor replaced by non-whitespace

When replaced by non-whitespace. Some of them exit successfully without print anything (`echo<20`). But most others failed to execute due to one of following reasons:

```
source0: source0: cannot execute binary file
source1: line 1: $'echo\00120': command not found
source34: line 1: unexpected EOF while looking for matching `"'
source47: line 1: echo/20: No such file or directory
source91: line 2: syntax error: unexpected end of file

```

---

Tomorrow: Your source code contains at least one `"` character. Your source code does not contain `'` character. When replacing all the `"` characters by `'` characters, your program print a prime factor of 21. (Your program print 3 or print 7).

# Answer
> 1 votes
# Day 20, bosh, score 2

```
wc -L<$0	#xyz

```

(there's a tab between the `0` and the `#`)

Try it online!

Satisfies:

* All unique bytes
* Whitespace can't be removed or replaced:
    + space removed: breaks the `wc -L` command
    + tab removed: `wc -L` prints the line length; the tab is wider than a single character; so the length changes if any other character is put there

---

Restriction for tomorrow:

> Since it's Noël, the code must contain all of the letters in the lowercase Latin alphabet, except L, (noël, no L, get it?) exactly once, and no uppercase letters, and if any single letter is removed, your program breaks.

# Answer
> 1 votes
# Day 21, Retina, score 2

```

pyfgcraoeuidhtnsqjkxbmwvz"
.........................

[!-#]
21
[&-(]
7

```

Try it online!

* No `'` but `"`, print 7 if `"` got replaced
* No `A-Z`, but all `a-km-z`, break while anyone removed.

---

Tomorrow: Different bytes occurred different times in your source code.

You may verify it by using following Python code:

```
source = b"abbbcc"

counts = list(map(source.count, set(source)))
print(len(counts) == len(set(counts)))

```

Try it online!

# Answer
> 1 votes
# Day 21, Zsh, score 2

```
tr a-z \"-f<<<d|/bin/gr?p -q %
h= k= m= s= u= v= w= x= y= echo $[j=21-?*14]

```

Try it online!

Satisfies both restrictions.

---

Restriction for tomorrow:

> Your program must still work as expected when its source code is put through ROT 13 and then executed.

# Answer
> 1 votes
# Day 21, Befunge-93, score 2

(I'm considering Befunge-93 distinct from Befunge-98 following the same logic that makes Python 2 distinct from Python 3.)

```
abcdefghijkmnopq"^"rstuv
wxyz          @.3<@.*37<

```

Removing any of the letters will disconnect the `v` at the end of the first line from the `<` at the end of the second line, causing the code to infinite loop. Replacing the `"`s with `'`s causes the `'` to be ignored as an unknown instruction, redirecting execution to the first `<` on the second line and causing `3` to be printed.

Answers tomorrow may use the restriction that they still work if every byte is increased by exactly 22, wrapping around from 256 to zero if necessary.

Try it online!

# Answer
> 1 votes
# Day 22, PowerShell, score 3

xxd:

```
00000000: 0d65 6368 6f20 3232 0a72 7075 6220 3232  .echo 22.rpub 22
00000010: 0af4 f44f 4d52 590a 1c1c f40d 0d0d 0d0d  ...OMRY.........
00000020: 0d0d 0d0d 0d0d 0d0d 0d0d 0d0d 0d0d 0d23  ...............#
00000030: 2323 2323 2323 2323 2323 2323 2323 2323  ################
00000040: 2323 4d4f 4f52 5252 5959 5959 6262 6262  ##MOORRRYYYYbbbb
00000050: 6263 6363 6363 6365 6565 6565 6565 6868  bcccccceeeeeeehh
00000060: 6868 6868 6868 6f6f 6f6f 6f6f 6f6f 6f70  hhhhhhooooooooop
00000070: 7070 7070 7070 7070 7072 7272 7272 7272  ppppppppprrrrrrr
00000080: 7272 7272 7575 7575 7575 7575 7575 7575  rrrruuuuuuuuuuuu
00000090: 1c1c 1c1c 1c1c 1c1c 1c1c 1c1c 2020 2020  ............
000000a0: 2020 2020 2020 2020 200a 0a0a 0a0a 0a0a           .......
000000b0: 0a0a 0a0a 0a0a f4f4 f4f4 f4f4 f4f4 f4f4  ................
000000c0: f4f4 f4f4 3232 3232 3232 3232 3232 3232  ....222222222222
000000d0: 3232                                     22

```

Try it online!

* Different byte different count
* Work after add 22
* Work after rot 13

---

Tomorrow: Your source code contains 2n bytes, while n bytes are in 0~127, and n byes are in 128~255.

# Answer
> 1 votes
# Day 22, Minimal-2D, score 3

```
DQ?
RE++++++++++++++++++++++.
EE...QQQQRRRRR???????

```

As written, the `D` redirects the code downwards to the second line, `R` redirects the code back rightwards, `E` is ignored as an unknown character, and `+` and `.` act like Brainfuck, printing the character with codepoint 22. Try it online!

If you ROT13 the code, the the `D` becomes `Q` which is ignored as unrecognized, the `Q` becomes `D`, redirecting code downward to the `E` (now rotated to `R`) where it rejoins the path of the non-rotated code (as `+` and `.` are not letters so don't get ROT13-ed. Try it rotated!

If you increase each byte by 22, then the `D` and `Q` turn into `Z` and `g`, which are both ignored, and the unprintable characters after them become `+` and `.`, which work as Brainfuck and print 22. Then, the `?` after the unprintables becomes `U`, redirecting the code out of bounds and terminating execution. Try it increased

The third line is useless junk added to satisfy the byte count restriction. Verify it satisfies that restriction!.

Answers tomorrow may use the restriction that each byte be the same or higher modulo 23 than the previous byte.

# Answer
> 1 votes
# Day 23, Noether, score 2

```
23P㈷

```

Try it online!

* Bytes mod 23 increase (4, 5, 11, 20, 21, 22)
* 3 bytes \< 128, 3 bytes \>= 128

The character at the end of program is ㈷, do not be confused with ㊗祝祝. 祝 means good wishes. So, maybe for anyone who enjoy a holiday today...

Yet another day randomly pick a language on TIO, and try if it works, repeat until finally got one.

---

Tomorrow: Odd positions may only be even bytes while even positions may only be odd bytes. Positions are 0-indexed.

# Answer
> 1 votes
# Day 23, Deadfish, score 2

```
iiiiiiiiiiiiiiiiiiiiiiioúúúúúúúúúúúúúúúúúúúúúúúú

```

Consists of 23 `i` (13 mod 23), then one `o` (19 mod 23), then 24 `ú` (20 mod 23). The `ú` at the end don't do anything other than make the code satisfy tsh's restriction about bytes \>128 .

Satisfies both restrictions.

Answers tommorrow may use the restriction that no program with an edit distance of one from your code prints a different number using the same output method as your code.

(The point of "using the same output method" is that every program technically prints a number via exit code, meaning that the restriction would otherwise be much harder to satisfy)

---
Tags: kolmogorov-complexity, restricted-source, answer-chaining
---