# 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.

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

# 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
• Sandbox – caird coinheringaahing Dec 2 '20 at 0:01
• @roblogic Within a few days the post with say “Asked on Dec 2 '20 at 00:00” but until then, this comment should suffice – caird coinheringaahing Dec 2 '20 at 1:30
• For the formatting, I think the "tomorrow's restriction" part should go after the "this solution follows these restrictions" part. – Bubbler Dec 2 '20 at 2:36
• Just a reminder for all: my timezone is the same as UTC, so I may potentially be asleep at 00:00 UTC. If the list of restrictions has not been updated by 2:00 UTC, I'm likely asleep, so I'd appreciate anyone being willing to update it in such a case. – caird coinheringaahing Dec 4 '20 at 1:01
• @SunnyMoon all previous days, otherwise the challenge never ends – caird coinheringaahing Dec 4 '20 at 16:15

# Day 5, A, 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 As, so is treated identically. Rotating it by any other number will result in there being no As, 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)

• Note that my restriction isn't trivial to do, because while some of the restrictions are trivial not to meet, some of them are hard not to meet. For example, a program must either be invalid UTF8 (tsh, day 3) or contain no vowels (noodle9, day 1) – pppery Dec 6 '20 at 19:27
• +1 on that restriction, it’s deceptively difficult and very creative – caird coinheringaahing Dec 6 '20 at 19:31
• Another subtle note about my restriction: it is undecidable by virtue of incorporating undecidable restrictions, and thus any program that satisfies only this day 6 restriction ends up trivially satisfying NieDzejkob's day 3 restriction (and thus can't satisfy any other day 1-4 restrictions) – pppery Dec 6 '20 at 19:37
• Hold on, what exactly is the restriction? For each previous day, satisfy at most one, or from all days at once, satisfy at most one? – NieDzejkob Dec 7 '20 at 9:01
• To my understanding, If at most one for every previous day, "Day 4. follow half or less of all the other restrictions" could be the only one... – tsh Dec 7 '20 at 10:05

# 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).

# 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))  • Could you please explain your restriction a bit more? Do you mean that when the code is taken as a huge number in base 256, it is a prime? In that case, didn't you mean bytes_to_long instead of long_to_bytes? – Ramillies Dec 5 '20 at 2:15 • @Ramillies Ah, damn it. I literally woke up realizing "I should check whether I didn't make that mistake". Fixed. I should've tested my code, even this simple >_< – NieDzejkob Dec 5 '20 at 8:51 # 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. # 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). • ...I just realised that a newline isn't 0x10, it's just 10 (as in decimal). Whoops – caird coinheringaahing Dec 2 '20 at 0:14 • @cairdcoinheringaahing If you want to fix it I could replace them in this code without it affecting anything – Redwolf Programs Dec 2 '20 at 0:19 • No, it's fine. I don't think many languages will suffer too drastically, and it'll change in a day – caird coinheringaahing Dec 2 '20 at 0:20 • @Bubbler I did, under the Try it Online link – Redwolf Programs Dec 2 '20 at 0:31 • Oops, sorry. Maybe moving it to the bottom will make it easier to find. – Bubbler Dec 2 '20 at 0:33 # 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. • "Byte values must be a multiple of 69" Is this means the program may only contains \x45, \x8a, \xcf? – tsh Dec 2 '20 at 7:25 • @tsh yes that's right if you are using a sbcs. If you use utf-8, there is an vastly greater amount of bytes available – lyxal Dec 2 '20 at 21:38 # 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. # 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. • Does "use a byte" mean at least one of \x02, \x03, \x05, \x07 or exactly one of \x02, \x03, \x05, \x07? If is exactly one, does it need to be used only once? – tsh Dec 2 '20 at 7:28 • @tsh I clarified in the answer. – Razetime Dec 2 '20 at 7:34 # 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  • I‘m getting an error on the TIO link: "Permalink could not be decoded properly"? – caird coinheringaahing Dec 2 '20 at 2:23 • The link should work now, it looks like I deleted a character. – Jonathan Allan Dec 2 '20 at 2:31 • Oops, I think we tried to fix formatting things at the same time, sorry if I messed anything up – Redwolf Programs Dec 2 '20 at 2:34 • @RedwolfPrograms yeah, no problem – Jonathan Allan Dec 2 '20 at 2:35 • By saying "works if reversed", Should the reversed one behavior as same as the original one, or the reverse one only need to exit successfully (normally with exit code 0 on most platform)? – tsh Dec 2 '20 at 7:23 # 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. • For some reason, the SE app on my phone shows 0x10 bytes as the ✊ emoji, so it‘s been fun seeing the new answers roll in, especially this one – caird coinheringaahing Dec 2 '20 at 16:50 • I'm not sure, but I think Unary requires zeroes, so maybe Lenguage would be more appropriate here. Congratulations on such a short answer though, my best Unary answer is a gazillion bytes ;) – user Dec 2 '20 at 17:22 • @user Per Dennis in codegolf.stackexchange.com/a/110653/46076, most Unary transpilers don't care which character is used. Languages are defined by their implementation on CGCC so this is valid. Besides, this way I can use Lenguage on day 2! – pppery Dec 2 '20 at 19:33 # 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.

• The restriction "the bytes of the program, when sorted and duplicates removed, are all consecutive" is for tomorrow, not today. Check the question text for the current day;s restrictions – caird coinheringaahing Dec 3 '20 at 2:42
• @cairdcoinheringaahing ah, so sad. I had removed it... – tsh Dec 3 '20 at 2:43

# Day 2. 99, score 7

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

=>=>=>=>=>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 :)

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

# 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


# 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.

• I just noticed that maybe the restriction could be done by using UTF-16 source code... – tsh Dec 14 '20 at 3:53

# 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, ...)

# 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.

• I'm not sure I understand the restriction? 0x00 0x01 0x02 are consecutive when sorted and deduplicated – caird coinheringaahing Dec 3 '20 at 2:43
• Oops, that’s a typo – user Dec 3 '20 at 2:56

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). • That's definitely a novel restriction, and I'd be very interested to see any answers tomorrow that use it – caird coinheringaahing Dec 3 '20 at 23:16 # 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)  • +1 for raise hell :D – Ramillies Dec 5 '20 at 16:40 • How is rotn defined exactly? – pppery Dec 6 '20 at 18:30 • @pppery Bytes in [a-z] get transformed as (c - 'a' + n) % 26 + 'a'. Likewise for uppercase. Rest is unchanged. – NieDzejkob Dec 6 '20 at 18:54 # 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)

# 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.

• Let me find out a programming language print 10 for A (hex 10)... Maybe there is one. – tsh Dec 11 '20 at 2:36
• @tsh CJam works, but it's already been used. – pppery Dec 11 '20 at 2:51
• Sad story. I'm still randomly picking some languages from TIO... – tsh Dec 11 '20 at 2:57

# 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!

• Python 2 still not used? WHY! That's... strange... – tsh Dec 14 '20 at 4:08
• Lots of restrictions that rule out or make inconvenient practical languages, I think. – pppery Dec 14 '20 at 4:24

# 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


# 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]/.

• Is Y a vowel? – SunnyMoon Dec 2 '20 at 13:34
• @SunnyMoon Edited answer to make that explicit. :-) – Noodle9 Dec 2 '20 at 14:03

# 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!

• You might want to specify that you use UTF-8 encoding, instead of 05AB1E's own encoding. Otherwise the 0x10 byte would be Γ. – Kevin Cruijssen Dec 2 '20 at 15:54
• Oh, that is what that page is for! Everything makes more sense now! – SunnyMoon Dec 2 '20 at 16:26

# 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.

• Can you edit in a restriction for answers to use tomorrow? – caird coinheringaahing Dec 3 '20 at 2:46
• Did you intentionally use the same restriction as me? – pppery Dec 3 '20 at 4:51
• @pppery Oops, didn't see yours. I will change the restriction. – PkmnQ Dec 3 '20 at 7:40

# 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 = F18.)
• 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.)

# 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.

• Do you mean any sub-sequence of the source code should not prints 4? If my program is print(4). Any sub-sequence would not fit the requirement of this question. But program p4 outputs 1:1 Undefined variable: p4 to stderr which contains 4 in its output. Is my source code still valid to this restriction? – tsh Dec 4 '20 at 2:07
• print(4) would satisfy this restriction. The point was to prevent adding useless fluff to satisfy other restrictions, not to make the base problem harder to solve. – pppery Dec 4 '20 at 2:13
• I missed a restriction added by tsh yesterday, so you might be able to claim a score of 6 ("Your source code must form a valid UTF-8 stream."). Also, it looks like a score of 4 is almost guaranteed, 6 is (mostly) doable and 8 is practically impossible, so that's fun – caird coinheringaahing Dec 4 '20 at 2:50

# 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).

• Because not all languages use UTF8, I'd recommend adding in the bytes that make up "unprintable characters" – caird coinheringaahing Dec 4 '20 at 2:47
• I missed a restriction from yesterday in the question ("Your source code must form a valid UTF-8 stream."), so it looks like you should be able to claim a score of 6 – caird coinheringaahing Dec 4 '20 at 2:52

# 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.

• Sorry, I made a mistake in my restriction, the code as written was impossible to satisfy. You may wish to edit your answer. – NieDzejkob Dec 5 '20 at 8:55
• @NieDzejkob OK, done. Effectively amounted to rewriting the code from scratch. – pppery Dec 5 '20 at 17:03

# 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.

# 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).