Quickly! Group together!

Question

As of 27/12/20, the challenge is over as no new answers were posted on the 26^th. 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 answer-chaining question, in that new answers will (somewhat) depend on old answers. However, this is (as far as I can tell) a unique form of answer-chaining, so be sure to read the entire challenge if you'd like to take part.

Normally, answer-chaining 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 restricted-source or source-layout, 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 1

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 2

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)

Answer 3

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 4

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

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

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 7

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 8

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 9

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 10

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 11

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 12

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

Answer 13

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 14

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 15

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 16

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 17

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 18

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 19

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 20

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 21

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 22

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 23

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 24

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 25

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₁₈.)
• 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 26

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 27

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 28

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 29

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 30

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