Examine individual changes
This page allows you to examine the variables generated by the Abuse Filter for an individual change.
Variables generated for this change
| Variable | Value |
|---|---|
Edit count of the user (user_editcount) | 3 |
Name of the user account (user_name) | 'Dragoneater67' |
Age of the user account (user_age) | 269639 |
Page ID (page_id) | 0 |
Page namespace (page_namespace) | 0 |
Page title (without namespace) (page_title) | '☭' |
Full page title (page_prefixedtitle) | '☭' |
Action (action) | 'edit' |
Edit summary/reason (summary) | '' |
Old content model (old_content_model) | '' |
New content model (new_content_model) | 'wikitext' |
Old page wikitext, before the edit (old_wikitext) | '' |
New page wikitext, after the edit (new_wikitext) | '{{infobox proglang
|name=☭
|paradigms=imperative<br>turing tarpit
|author=[[User:Dragoneater67|Dragoneater67]]
|year=[[:Category:2026|2026]]
|memsys=[[:Category:Cell-based|Cell-based]]
|dimensions=one-dimensional
|class=[[:Category:Turing complete|Turing complete]]
|majorimpl=[https://pastebin.com/sJR24nnN C++]
|influence=[[Sharp_flat|#b]]<br>[[!I!M!P!O!S!S!I!B!L!E!]]<br>[[Brainfuck]]
|files=<code>.hammerandsickle</code>
}}
'''☭''' is a [[Turing complete|turing complete]] [[Esoteric programming language|esoteric programming language]]. The goal of the language is to make doing trivial operations nearly impossible.
==Overview==
The language is separated into 2 phases of execution. The overview is very brief as it is hard to explain the workings of ☭. Refer to the reference implementation to get a better understanding of the language.
===Phase 1===
Phase 1 reads the source string character-by-character and executes a command. Before each command is executed g is regenerated using LCG (the initial seed for g is <math>89404137</math>). The command is determined by this formula (<math>c</math> is the current character, <math>i</math> is the position of the current character):<br>
<math>\left(\left(\left((c \oplus q) + (i \bmod 3) + (g \gg 24)\right) \bmod 3\right) + 3\right) \bmod 3</math>
{| class="wikitable"
! Selector !! Type !! Operation
|-
| style="text-align:center;" | '''0'''
| State mutation
| Mutates internal accumulators and shifts keys:
* <tt>a += 3</tt>
* <tt>w += 7</tt>
* <tt>q -= 43</tt> (Input key rotation)
* <tt>p -= 13</tt> (Memory pointer shift)
* <tt>g ^= 0xCAFEBABE</tt> (PRNG scramble)
|-
| style="text-align:center;" | '''1'''
| State mutation
| Mutates internal accumulators and shifts keys:
* <tt>a -= 2</tt>
* <tt>w -= 5</tt>
* <tt>q += 67</tt> (Input key rotation)
* <tt>p += 17</tt> (Memory pointer shift)
* <tt>g += a ^ w</tt> (PRNG mix)
|-
| style="text-align:center;" | '''2'''
| Instruction generation
| Synthesizes a candidate byte <tt>b</tt> using the formula:
<math>b = \neg \left( \left( (a \lor w) \land h \right) \oplus q \oplus (g \land \text{0xFF}) \right)</math><br>
If <tt>b</tt> is a valid instruction (<tt>*</tt>, <tt>#</tt>, or <tt>?</tt>), it is appended to the Phase 2 instruction tape.<br>
If <tt>b</tt> is invalid, the PRNG is penalized (<tt>g = 0xDEADBEEF</tt>).
|}
===Phase 2===
Phase 2 is a virtual machine that executes the bytecode generated in phase 1.
The virtual machine has:
* The memory tape with the length of <math>10^6</math> bytes
* The instruction tape with the length of <math>2^{31}-1</math> bytes
* The memory pointer
* The instruction pointer
The memory pointer is initially pseudorandom (derived from the source string), while the instruction pointer is always initialized to <math>0</math>. Instructions are single ASCII characters, any other ASCII character is an invalid character and will result in an error. Here is a quick overview of available commands:
{| class="wikitable"
! Instruction !! Condition !! Operation
|-
| rowspan="2" style="text-align:center; font-family:monospace; font-size:1.2em;" | *
| Instruction pointer is '''Odd'''
| Adds 251 to the current memory cell, then moves the memory pointer forward by 999983 positions.
|-
| Instruction pointer is '''Even'''
| Reads a byte from input, XORs it with register <tt>q</tt>, and stores it in the current memory cell, then jumps back 2 steps.
|-
| rowspan="2" style="text-align:center; font-family:monospace; font-size:1.2em;" | #
| Current memory cell is '''0'''
| Jumps back 7 steps, then modifies the instruction at that location by cycling it (<tt>*</tt> → <tt>#</tt> → <tt>?</tt> → <tt>*</tt> → ...).
|-
| Current memory cell is '''not 0'''
| Moves the memory pointer backward by 999979 positions, then adds 241 to the current memory cell.
|-
| rowspan="2" style="text-align:center; font-family:monospace; font-size:1.2em;" | ?
| Memory pointer is '''Odd'''
| Outputs the character at the current memory cell XORed with register <tt>h</tt>, then adds 239 to the current memory cell.
|-
| Memory pointer is '''Even'''
| If current memory cell is 0, skip forward 13 instructions. Otherwise, set both memory pointer and the instruction pointer to pseudo-random values derived from <tt>g</tt>.
|}
The virtual machine has the following internal registers:
* a (phase 1 only, does not affect the state of the virtual machine)
* w (phase 1 only, does not affect the state of the virtual machine)
* h (the rolling encryption key for output)
* q (the rolling encryption key for input)
* p (the memory pointer)
* j (the instruction count)
* y (the instruction pointer)
* g (pseudo-random value)
After each instruction is executed the new <tt>h</tt> is calculated using this formula (<math>t_p</math> is current memory cell value and <math>b_y</math> is the current instruction):<br>
<math>h_{new} = ((g \gg 16) \land \text{0xFF}) \oplus h \oplus (t_p \land (b_y \lor q))</math>
==Computational class==
☭ as mentioned earlier, is [[Turing complete|turing complete]], but may be considered a [[Turing tarpit|turing tarpit]] by some.
* The <tt>*</tt> and <tt>#</tt> instructions allow for arbitrary arithmetic operations since they can increment values of memory cells
* The <tt>?</tt> and <tt>#</tt> instructions allow for complex control flow because of conditional jumps and self-modifying code
* The <tt>*</tt> and <tt>?</tt> instructions allow for input/output operations, although not required for [[Turing completeness|turing completeness]], they are still very useful for some use cases (such as printing "Hello world!")
==Examples==
No ☭ program has been discovered yet.
==External resources==
* [https://pastebin.com/sJR24nnN Reference implementation written in C++]
[[Category:Turing tarpits]]
[[Category:Low-level]]
[[Category:Cell-based]]
[[Category:Implemented]]
[[Category:Languages]]
[[Category:2026]]
[[Category:Turing complete]]' |
Unified diff of changes made by edit (edit_diff) | '@@ -1,0 +1,106 @@
+{{infobox proglang
+|name=☭
+|paradigms=imperative<br>turing tarpit
+|author=[[User:Dragoneater67|Dragoneater67]]
+|year=[[:Category:2026|2026]]
+|memsys=[[:Category:Cell-based|Cell-based]]
+|dimensions=one-dimensional
+|class=[[:Category:Turing complete|Turing complete]]
+|majorimpl=[https://pastebin.com/sJR24nnN C++]
+|influence=[[Sharp_flat|#b]]<br>[[!I!M!P!O!S!S!I!B!L!E!]]<br>[[Brainfuck]]
+|files=<code>.hammerandsickle</code>
+}}
+'''☭''' is a [[Turing complete|turing complete]] [[Esoteric programming language|esoteric programming language]]. The goal of the language is to make doing trivial operations nearly impossible.
+==Overview==
+The language is separated into 2 phases of execution. The overview is very brief as it is hard to explain the workings of ☭. Refer to the reference implementation to get a better understanding of the language.
+===Phase 1===
+Phase 1 reads the source string character-by-character and executes a command. Before each command is executed g is regenerated using LCG (the initial seed for g is <math>89404137</math>). The command is determined by this formula (<math>c</math> is the current character, <math>i</math> is the position of the current character):<br>
+<math>\left(\left(\left((c \oplus q) + (i \bmod 3) + (g \gg 24)\right) \bmod 3\right) + 3\right) \bmod 3</math>
+{| class="wikitable"
+! Selector !! Type !! Operation
+|-
+| style="text-align:center;" | '''0'''
+| State mutation
+| Mutates internal accumulators and shifts keys:
+* <tt>a += 3</tt>
+* <tt>w += 7</tt>
+* <tt>q -= 43</tt> (Input key rotation)
+* <tt>p -= 13</tt> (Memory pointer shift)
+* <tt>g ^= 0xCAFEBABE</tt> (PRNG scramble)
+|-
+| style="text-align:center;" | '''1'''
+| State mutation
+| Mutates internal accumulators and shifts keys:
+* <tt>a -= 2</tt>
+* <tt>w -= 5</tt>
+* <tt>q += 67</tt> (Input key rotation)
+* <tt>p += 17</tt> (Memory pointer shift)
+* <tt>g += a ^ w</tt> (PRNG mix)
+|-
+| style="text-align:center;" | '''2'''
+| Instruction generation
+| Synthesizes a candidate byte <tt>b</tt> using the formula:
+<math>b = \neg \left( \left( (a \lor w) \land h \right) \oplus q \oplus (g \land \text{0xFF}) \right)</math><br>
+If <tt>b</tt> is a valid instruction (<tt>*</tt>, <tt>#</tt>, or <tt>?</tt>), it is appended to the Phase 2 instruction tape.<br>
+If <tt>b</tt> is invalid, the PRNG is penalized (<tt>g = 0xDEADBEEF</tt>).
+|}
+===Phase 2===
+Phase 2 is a virtual machine that executes the bytecode generated in phase 1.
+The virtual machine has:
+* The memory tape with the length of <math>10^6</math> bytes
+* The instruction tape with the length of <math>2^{31}-1</math> bytes
+* The memory pointer
+* The instruction pointer
+The memory pointer is initially pseudorandom (derived from the source string), while the instruction pointer is always initialized to <math>0</math>. Instructions are single ASCII characters, any other ASCII character is an invalid character and will result in an error. Here is a quick overview of available commands:
+{| class="wikitable"
+! Instruction !! Condition !! Operation
+|-
+| rowspan="2" style="text-align:center; font-family:monospace; font-size:1.2em;" | *
+| Instruction pointer is '''Odd'''
+| Adds 251 to the current memory cell, then moves the memory pointer forward by 999983 positions.
+|-
+| Instruction pointer is '''Even'''
+| Reads a byte from input, XORs it with register <tt>q</tt>, and stores it in the current memory cell, then jumps back 2 steps.
+|-
+| rowspan="2" style="text-align:center; font-family:monospace; font-size:1.2em;" | #
+| Current memory cell is '''0'''
+| Jumps back 7 steps, then modifies the instruction at that location by cycling it (<tt>*</tt> → <tt>#</tt> → <tt>?</tt> → <tt>*</tt> → ...).
+|-
+| Current memory cell is '''not 0'''
+| Moves the memory pointer backward by 999979 positions, then adds 241 to the current memory cell.
+|-
+| rowspan="2" style="text-align:center; font-family:monospace; font-size:1.2em;" | ?
+| Memory pointer is '''Odd'''
+| Outputs the character at the current memory cell XORed with register <tt>h</tt>, then adds 239 to the current memory cell.
+|-
+| Memory pointer is '''Even'''
+| If current memory cell is 0, skip forward 13 instructions. Otherwise, set both memory pointer and the instruction pointer to pseudo-random values derived from <tt>g</tt>.
+|}
+The virtual machine has the following internal registers:
+* a (phase 1 only, does not affect the state of the virtual machine)
+* w (phase 1 only, does not affect the state of the virtual machine)
+* h (the rolling encryption key for output)
+* q (the rolling encryption key for input)
+* p (the memory pointer)
+* j (the instruction count)
+* y (the instruction pointer)
+* g (pseudo-random value)
+After each instruction is executed the new <tt>h</tt> is calculated using this formula (<math>t_p</math> is current memory cell value and <math>b_y</math> is the current instruction):<br>
+<math>h_{new} = ((g \gg 16) \land \text{0xFF}) \oplus h \oplus (t_p \land (b_y \lor q))</math>
+==Computational class==
+☭ as mentioned earlier, is [[Turing complete|turing complete]], but may be considered a [[Turing tarpit|turing tarpit]] by some.
+* The <tt>*</tt> and <tt>#</tt> instructions allow for arbitrary arithmetic operations since they can increment values of memory cells
+* The <tt>?</tt> and <tt>#</tt> instructions allow for complex control flow because of conditional jumps and self-modifying code
+* The <tt>*</tt> and <tt>?</tt> instructions allow for input/output operations, although not required for [[Turing completeness|turing completeness]], they are still very useful for some use cases (such as printing "Hello world!")
+==Examples==
+No ☭ program has been discovered yet.
+==External resources==
+* [https://pastebin.com/sJR24nnN Reference implementation written in C++]
+
+[[Category:Turing tarpits]]
+[[Category:Low-level]]
+[[Category:Cell-based]]
+[[Category:Implemented]]
+[[Category:Languages]]
+[[Category:2026]]
+[[Category:Turing complete]]
' |
New page size (new_size) | 5917 |
Old page size (old_size) | 0 |
Lines added in edit (added_lines) | [
0 => '{{infobox proglang',
1 => '|name=☭',
2 => '|paradigms=imperative<br>turing tarpit',
3 => '|author=[[User:Dragoneater67|Dragoneater67]]',
4 => '|year=[[:Category:2026|2026]]',
5 => '|memsys=[[:Category:Cell-based|Cell-based]]',
6 => '|dimensions=one-dimensional',
7 => '|class=[[:Category:Turing complete|Turing complete]]',
8 => '|majorimpl=[https://pastebin.com/sJR24nnN C++]',
9 => '|influence=[[Sharp_flat|#b]]<br>[[!I!M!P!O!S!S!I!B!L!E!]]<br>[[Brainfuck]]',
10 => '|files=<code>.hammerandsickle</code>',
11 => '}}',
12 => ''''☭''' is a [[Turing complete|turing complete]] [[Esoteric programming language|esoteric programming language]]. The goal of the language is to make doing trivial operations nearly impossible.',
13 => '==Overview==',
14 => 'The language is separated into 2 phases of execution. The overview is very brief as it is hard to explain the workings of ☭. Refer to the reference implementation to get a better understanding of the language.',
15 => '===Phase 1===',
16 => 'Phase 1 reads the source string character-by-character and executes a command. Before each command is executed g is regenerated using LCG (the initial seed for g is <math>89404137</math>). The command is determined by this formula (<math>c</math> is the current character, <math>i</math> is the position of the current character):<br>',
17 => '<math>\left(\left(\left((c \oplus q) + (i \bmod 3) + (g \gg 24)\right) \bmod 3\right) + 3\right) \bmod 3</math>',
18 => '{| class="wikitable"',
19 => '! Selector !! Type !! Operation',
20 => '|-',
21 => '| style="text-align:center;" | '''0'''',
22 => '| State mutation',
23 => '| Mutates internal accumulators and shifts keys:',
24 => '* <tt>a += 3</tt>',
25 => '* <tt>w += 7</tt>',
26 => '* <tt>q -= 43</tt> (Input key rotation)',
27 => '* <tt>p -= 13</tt> (Memory pointer shift)',
28 => '* <tt>g ^= 0xCAFEBABE</tt> (PRNG scramble)',
29 => '|-',
30 => '| style="text-align:center;" | '''1'''',
31 => '| State mutation',
32 => '| Mutates internal accumulators and shifts keys:',
33 => '* <tt>a -= 2</tt>',
34 => '* <tt>w -= 5</tt>',
35 => '* <tt>q += 67</tt> (Input key rotation)',
36 => '* <tt>p += 17</tt> (Memory pointer shift)',
37 => '* <tt>g += a ^ w</tt> (PRNG mix)',
38 => '|-',
39 => '| style="text-align:center;" | '''2'''',
40 => '| Instruction generation',
41 => '| Synthesizes a candidate byte <tt>b</tt> using the formula:',
42 => '<math>b = \neg \left( \left( (a \lor w) \land h \right) \oplus q \oplus (g \land \text{0xFF}) \right)</math><br>',
43 => 'If <tt>b</tt> is a valid instruction (<tt>*</tt>, <tt>#</tt>, or <tt>?</tt>), it is appended to the Phase 2 instruction tape.<br>',
44 => 'If <tt>b</tt> is invalid, the PRNG is penalized (<tt>g = 0xDEADBEEF</tt>).',
45 => '|}',
46 => '===Phase 2===',
47 => 'Phase 2 is a virtual machine that executes the bytecode generated in phase 1.',
48 => 'The virtual machine has:',
49 => '* The memory tape with the length of <math>10^6</math> bytes',
50 => '* The instruction tape with the length of <math>2^{31}-1</math> bytes',
51 => '* The memory pointer',
52 => '* The instruction pointer',
53 => 'The memory pointer is initially pseudorandom (derived from the source string), while the instruction pointer is always initialized to <math>0</math>. Instructions are single ASCII characters, any other ASCII character is an invalid character and will result in an error. Here is a quick overview of available commands:',
54 => '{| class="wikitable"',
55 => '! Instruction !! Condition !! Operation',
56 => '|-',
57 => '| rowspan="2" style="text-align:center; font-family:monospace; font-size:1.2em;" | *',
58 => '| Instruction pointer is '''Odd'''',
59 => '| Adds 251 to the current memory cell, then moves the memory pointer forward by 999983 positions.',
60 => '|-',
61 => '| Instruction pointer is '''Even'''',
62 => '| Reads a byte from input, XORs it with register <tt>q</tt>, and stores it in the current memory cell, then jumps back 2 steps.',
63 => '|-',
64 => '| rowspan="2" style="text-align:center; font-family:monospace; font-size:1.2em;" | #',
65 => '| Current memory cell is '''0'''',
66 => '| Jumps back 7 steps, then modifies the instruction at that location by cycling it (<tt>*</tt> → <tt>#</tt> → <tt>?</tt> → <tt>*</tt> → ...).',
67 => '|-',
68 => '| Current memory cell is '''not 0'''',
69 => '| Moves the memory pointer backward by 999979 positions, then adds 241 to the current memory cell.',
70 => '|-',
71 => '| rowspan="2" style="text-align:center; font-family:monospace; font-size:1.2em;" | ?',
72 => '| Memory pointer is '''Odd'''',
73 => '| Outputs the character at the current memory cell XORed with register <tt>h</tt>, then adds 239 to the current memory cell.',
74 => '|-',
75 => '| Memory pointer is '''Even'''',
76 => '| If current memory cell is 0, skip forward 13 instructions. Otherwise, set both memory pointer and the instruction pointer to pseudo-random values derived from <tt>g</tt>.',
77 => '|}',
78 => 'The virtual machine has the following internal registers:',
79 => '* a (phase 1 only, does not affect the state of the virtual machine)',
80 => '* w (phase 1 only, does not affect the state of the virtual machine)',
81 => '* h (the rolling encryption key for output)',
82 => '* q (the rolling encryption key for input)',
83 => '* p (the memory pointer)',
84 => '* j (the instruction count)',
85 => '* y (the instruction pointer)',
86 => '* g (pseudo-random value)',
87 => 'After each instruction is executed the new <tt>h</tt> is calculated using this formula (<math>t_p</math> is current memory cell value and <math>b_y</math> is the current instruction):<br>',
88 => '<math>h_{new} = ((g \gg 16) \land \text{0xFF}) \oplus h \oplus (t_p \land (b_y \lor q))</math>',
89 => '==Computational class==',
90 => '☭ as mentioned earlier, is [[Turing complete|turing complete]], but may be considered a [[Turing tarpit|turing tarpit]] by some.',
91 => '* The <tt>*</tt> and <tt>#</tt> instructions allow for arbitrary arithmetic operations since they can increment values of memory cells',
92 => '* The <tt>?</tt> and <tt>#</tt> instructions allow for complex control flow because of conditional jumps and self-modifying code',
93 => '* The <tt>*</tt> and <tt>?</tt> instructions allow for input/output operations, although not required for [[Turing completeness|turing completeness]], they are still very useful for some use cases (such as printing "Hello world!")',
94 => '==Examples==',
95 => 'No ☭ program has been discovered yet.',
96 => '==External resources==',
97 => '* [https://pastebin.com/sJR24nnN Reference implementation written in C++]',
98 => '',
99 => '[[Category:Turing tarpits]] ',
100 => '[[Category:Low-level]] ',
101 => '[[Category:Cell-based]] ',
102 => '[[Category:Implemented]] ',
103 => '[[Category:Languages]]',
104 => '[[Category:2026]]',
105 => '[[Category:Turing complete]]'
] |
Unix timestamp of change (timestamp) | '1767981630' |