The Oflameron text programming language is developed exclusively in the form of AI prompts for generating a Program Translator and AI "compiler" prompts for writing programs.
Programs written in the Oflameron language are designed to hide text information using obfuscation and cryptography.
AI prompts allow each user to use their own versions of obfuscation and cryptography, changing them with each use.
The prompt is provided as is. The prompt specification is not final (beta version).
The MIT License:Licensing
(c) by Valery Shmelev    https://oflameron.com

-------------------------------------------------------------- Prompt #1 --------------------------------------------------------------------------------------

AI Prompt for the Language Translator https://github.com/vallshmeleff/oflameron-obfuscation-language

Prototype request version 1.40 (with character rotation)
Write HTML and JavaScript code for a web page optimized for viewing on a smartphone in portrait orientation.
Web page encoding: UTF-8

Interface elements:
Title: "Oflameron language interpreter ver 1.40 (with rotation)"

Field #1 (textarea): "Prime number (key for XOR cryptography)"

Initial value: 176684706477838432958329750074291851582748389687561895812160620129261977163358586401104946332014022802424840484736440263640058869150064213123847594034139965365510006253457917812163931669483321

Signature: "Enter the key as a string of numbers."

Field #2 (textarea): "Oflameron program source code." Contains all user-entered code, including unprocessed (blank) characters.

Field #3 (textarea): "Oflameron program code (clear)". The program code, cleared of unprocessed characters (not included in the list a, b, c, d, e, p, t, v, w, h, q, l, k, f, g, i, m, n, s, x). Changes every time changes are made to Field #2.

Field #4 (textarea, readonly): "Result / Ciphertext" in text form after pressing the RUN button.

Field #5 (textarea, readonly): "Result / Ciphertext" as a continuous decimal character code (e.g., instead of UVW characters, the decimal code 858687) without spaces.

Buttons:

RUN (run the interpreter)

XOR (operation with a key)

"Show rotation table" (for debugging)

Message block (div)

Rotation information block: "STP (rotation step by list a, b, c, d, e, p, t, v, w, h, q, l, k, f, g, i, m, n) = 1 (change in the web page's JavaScript code)"

Oflameron interpreter with rotation:
Variables, constants, and parameters:
h, q, l, k - numeric variables, initial value 0 for all

STP = 1 (rotation constant, changed by editing the web page's HTML code)

Constants and their values: a=0, b=1, c=3, d=5, e=7, p=19, t=23, v=43, w=73

// Initial symbol order
Variable SYMBOL_ORDER = ['a','b','c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n'];

The first 9 characters in the SYMBOL_ORDER variable are constant symbols (a, b, c, d, e, p, t, v, w)
Characters 10-13 are variables (h, q, l, k)
Characters 14-18 are operators (f, g, i, m, n)

Symbol rotation:
Principle: Cyclic shift of symbol functions to the right in the list by STP positions

When to rotate: Rotation is performed after (after!) the execution of EACH operator (f, g, i, l, m, nq).
That is, operators are executed in the current functionality. Then, a right shift is performed in the program code by 2 or 3 characters (depending on the operator length), followed by rotation (functionality shift), and the next operator is analyzed.

Rotation mechanics (examples):

a receives function b (value 1)

b receives function c (value 3)

n receives function a (value 0)

The functionality shift is performed after each statement is executed. So, the code entry fcdgbemc... should be considered as fcd(shift)gbe(shift)mc(shift)...
The columns of Table #1 show the initial contents (after the first application of the functionality shift) of SYMBOL_ORDER (table columns) for each STR value.

STP=		0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17
                               ------------------------------------------------------------------------------------------------------------ Executable function ---------------------------------------------------------------------------------------------------------
Константа a	a	b	c	d	e	p	t	v	w	h	q	l	k	f	g	i	m	n
Константа b	b	c	d	e	p	t	v	w	h	q	l	k	f	g	i	m	n	a
Константа c	c	d	e	p	t	v	w	h	q	l	k	f	g	i	m	n	a	b
Константа d	d	e	p	t	v	w	h	q	l	k	f	g	i	m	n	a	b	c
Константа e	e	p	t	v	w	h	q	l	k	f	g	i	m	n	a	b	c	d
Константа p	p	t	v	w	h	q	l	k	f	g	i	m	n	a	b	c	d	e
Константа t	t	v	w	h	q	l	k	f	g	i	m	n	a	b	c	d	e	p
Константа v	v	w	h	q	l	k	f	g	i	m	n	a	b	c	d	e	p	t
Константа w	w	h	q	l	k	f	g	i	m	n	a	b	c	d	e	p	t	v
Переменная h	h	q	l	k	f	g	i	m	n	a	b	c	d	e	p	t	v	w
Переменная q	q	l	k	f	g	i	m	n	a	b	c	d	e	p	t	v	w	h
Переменная l	l 	k	f	g	i	m	n	a	b	c	d	e	p	t	v	w	h	q
Переменная k	k	f	g	i	m	n	a	b	c	d	e	p	t	v	w	h	q	l
Оператор	f 	f	g	i	m	n	a	b	c	d	e	p	t	v	w	h	q	l	k
Оператор	g	g	i	m	n	a	b	c	d	e	p	t	v	w	h	q	l	k	f
Оператор	i	i	m	n	a	b	c	d	e	p	t	v	w	h	q	l	k	f	g
Оператор	m	m	n	a	b	c	d	e	p	t	v	w	h	q	l	k	f	g	i
Оператор	n	n	a	b	c	d	e	p	t	v	w	h	q	l	k	f	g	i	m



Errors: If after rotation, an operator receives an inappropriate arity, the operation is skipped.

Period: With STP=1, the rotation period = 18 operators.

Number normalization:
javascript
function normalize(num) {
while (num > 127) num -= 127;
if (num < 0) num = Math.abs(num);
return Math.floor(num);
}
Applied to the result after EVERY mathematical operation.

Valid operands:
Constants: a, b, c, d, e, p, t, v, w

Variables: h, q, l

k is used ONLY as an index, NOT as an operand

Operators (before rotation):
fXY - multiplication: h = normalize(X * Y) (k+3) - operator size = 3 characters

gXY - addition: h = normalize(X + Y) (k+3) - operator size = 3 characters

iXY - subtraction: h = normalize(Math.abs(X - Y)) (k+3) - operator size = 3 characters

lX - store the ASCII code of the character at position k + normalize(X) (k+2) in l - operator size = 2 characters. The exact character from the "cleaned" program line is read (i.e., constant, variable, operator).

mX - output the character with the normalize(X) code in field #4 (k+2) - operator size = 2 characters

nq - replace the character at position k + normalize(q) with the character with the normalize(h) code (k+2) - operator size = 2 characters. The character is replaced in the "cleaned" program code.

The characters s and x are reserved for version 1.50 and later.

General rules:
Code execution by line is strictly left-to-right.

k (the pointer in the program line) is only incremented.

Code movement:

f,g,i: k+3

l,m,nq: k+2

Error/unknown symbol: k+1 (simply move right one position in the program line)

Error: if an operand is expected, but the symbol is invalid > k+1

Unknown symbols: skipped (k+1)

Code line self-modification: via the nq operator

Reset on RUN: zero out h,q,l,k, clear field #3, reset rotation to the beginning

Cycle protection: maximum 100,000 steps

Rotation mechanics in detail:
Initial state: symbols have their original functions

After each operator:

The functionality of all symbols is shifted to the right by STP positions in the list according to Table #1.

New functions are applied starting with the next operator in the program code.

Example with STP=1:

text
Initial: a=0, b=1, c=3, d=5, ..., f=multiplication, g=addition
After the first operator: a=1, b=3, c=5, ..., f=addition, g=subtraction

XOR operation:
Performed: between key (field #1) and text (field #4)

Process:

Take N = min(key_length, text_length)

For i=0..N-1: result[i] = String.fromCharCode(key_code[i] ^ text_code[i])

Replace the contents of field #3 with the result.

Reversibility: XOR(XOR(text, key), key) = text

Show Rotation Table function:
Shows the current rotation state.

Format: "Symbol > Function (Value/Type)"

Example: "a > b (value 1), f > g (addition operator)"

Examples with rotation:
Example 1 (STP=1):

text
Source code: fbcgde
Step 1: fbc is performed as a multiplication (b*c = 1*3 = 3, h=3)
Rotation: all characters are shifted right by 1
Step 2: gde is now performed as a subtraction (g is now the i function)
Calculation: |d - e| = |5 - 7| = 2, h=2
Rotation: shift by 1 again
Example 2 (STP=2):

text
Source code: fbc
Step 1: fbc is performed as a multiplication (1*3=3, h=3)
Rotation: shift by 2 positions
Now: a>c(3), b>d(5), c>e(7), f>i(subtraction), etc.
Implementation requirements:
Pure HTML/CSS/JavaScript without external libraries

Responsive layout for mobile devices

RUN button: Runs the interpreter with the code from field #2, resetting the rotation

XOR button: Performs the XOR operation as described above

Show rotation table button: Shows the current state

Rotation implementation:

Array of functions for each symbol

The rotateSymbols() function is called after each operator

The conversion table is updated dynamically

Messages: Show rotation information in a separate div

Technical details of rotation implementation:
javascript
// Initial symbol order
Variable SYMBOL_ORDER = ['a','b','c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n'];

// Current symbol mapping to functions
let symbolMapping = createInitialMapping();

// Rotation function
function rotateSymbols() {
const newMapping = {};
for(let i = 0; i < SYMBOL_ORDER.length; i++) {
const fromSymbol = SYMBOL_ORDER[i];
// Shift right by STP
const toIndex = (i - STP + SYMBOL_ORDER.length) % SYMBOL_ORDER.length;
const toSymbol = SYMBOL_ORDER[toIndex];
newMapping[fromSymbol] = symbolMapping[toSymbol];
}
symbolMapping = newMapping;
}
The request now includes:

A complete symbol rotation specification

Clear execution rules

Examples of working with rotation

Debugging mechanism (table display button)

The prompt is regularly updated based on test results. All technical details for implementation https://chat.deepseek.com/share/5uv6th7lkivqkx5mv6
Direct List Prompt  https://github.com/vallshmeleff/oflameron-obfuscation-language
https://t.me/llmsource/429

-------------------------------------------------------------- Prompt #2 --------------------------------------------------------------------------------------

AI prompt for writing program code in the Oflameron language ("compiler") for version 1.50 with variable rotation. For compatibility with the Translator version 1.40, the control characters s and x must NOT be used.

Request to write a program in the Oflameron language version 1.50 ("compiler")
When executed in the Interpreter, an Oflameron program produces text (text, text script, or code listing of a language) specified by the user.

A description for converting the user-specified text into program code. The text to be encoded will be specified at the end of the request.

Program code in the Oflameron language is a text string that is scanned by the Interpreter from left to right.
Program code always begins with an operator.

Program code in the Oflameron language is a string of constants, operators, indices, control symbols, and ballast symbols.
The full character set used in Oflameron version 1.50 is a, b, c, d, e, p, t, v, w, h, q, l, k, f, g, i, m, n, s, and x. All other characters have no function in the Oflameron language and are simply omitted (these are filler characters added to hide program code).
Constants: a=0, b=1, c=3, d=5, e=7, p=19, t=23, v=43, w=73
Variables: h, q, l, k (Initial values ​​=0)
Operators: f, g, i, l, m, n
Control characters (actually also operators): s, x
Ballast symbols: all other symbols except the above a, b, c, d, e, p, t, v, w, h, q, l, k, f, g, i, m, n, s, x. Ballast characters are simply skipped by the translator.


The normalization function is used to transform characters in a given text. In JavaScript, it looks like this:
Number normalization:
javascript
function normalize(num) {
while (num > 127) num -= 127;
if (num < 0) num = Math.abs(num);
return Math.floor(num);
}
Applied to the result after EVERY mathematical operation. This is done to ensure that only character codes in the range 0-127 are used in the program.

Length of constants, variables, operators, and control characters:

* Important: Although the character l in a program code line must be treated as an operator with a length of two characters (the second character is the parameter), the result of the execution is stored in the variable l.
** If l occurs in the program code at the position of an operator f, g, i, m, or n, then l is a variable. For example: fal or gcl or ml... If l appears after an operator with parameters, then l in this case is an operator with a length of two characters. For example: fbcle or gcale, etc.

- constants are used as parameters in operators. Constants take up one character in the program code.
- variables are used as parameters in operators. Variables occupy 1 character in program code.
- Operators f, g, and i occupy 3 characters in a line of program code (the operator symbol f, g, or i and two parameters—variables or constants).
- Operators m, l, and n occupy two characters in program code (the operator symbol m, l, or n and one parameter).
- Control symbols s and x are 2 characters long.

JavaScript uses the internal variable SYMBOL_ORDER = ['a','b','c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n','s','x'] to determine the order of constants, variables, operators, and control symbols.

If SYMBOL_ORDER is considered an array with indices from 1 to 20, then:

Positions 1-9 in SYMBOL_ORDER are constants.
Positions 10-13 in SYMBOL_ORDER are variables.
Positions 14-18 in SYMBOL_ORDER are operators.
Positions 19-20 in SYMBOL_ORDER are control characters.

This is important for proper functionality rotation.
Functionality rotation is determined by the value of STP, an internal JavaScript variable.

If no explicit value is specified, STP=1 by default.

Rules for rotating the functionality of constants, variables, operators, and control symbols:

When to perform rotation: Rotation is performed after (after!) the execution of EACH operator (f, g, i, l, m, n).

If the value of the STP variable is nonzero, then after each execution of any operator, the functionality is shifted according to the following table.
The columns of the table show how the functionality of each symbol in SYMBOL_ORDER changes for each STR value.

STP=		0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19
		------------------------------------------------------------------------------------------------------------------- What functions does it perform -----------------------------------------------------------------------------------------------------------------
Константа a	a	b	c	d	e	p	t	v	w	h	q	l	k	f	g	i	m	n	s	x
Константа b	b	c	d	e	p	t	v	w	h	q	l	k	f	g	i	m	n	s	x	a
Константа c	c	d	e	p	t	v	w	h	q	l	k	f	g	i	m	n	s	x	a	b	
Константа d	d	e	p	t	v	w	h	q	l	k	f	g	i	m	n	s	x	a	b	c
Константа e	e	p	t	v	w	h	q	l	k	f	g	i	m	n	s	x	a	b	c	d
Константа p	p	t	v	w	h	q	l	k	f	g	i	m	n	s	x	a	b	c	d	e
Константа t	t	v	w	h	q	l	k	f	g	i	m	n	s	x	a	b	c	d	e	p
Константа v	v	w	h	q	l	k	f	g	i	m	n	s	x	a	b	c	d	e	p	t
Константа w	w	h	q	l	k	f	g	i	m	n	s	x	a	b	c	d	e	p	t	v
Переменная h	h	q	l	k	f	g	i	m	n	s	x	a	b	c	d	e	p	t	v	w
Переменная q 	q	l	k	f	g	i	m	n	s	x	a	b	c	d	e	p	t	v	w	h
Переменная l	l 	k	f	g	i	m	n	s	x	a	b	c	d	e	p	t	v	w	h	q
Переменная k	k	f	g	i	m	n	s	x	a	b	c	d	e	p	t	v	w	h	q	l
Оператор f	f	g	i	m	n	s	x	a	b	c	d	e	p	t	v	w	h	q	l	k
Оператор	g	g	i	m	n	s	x	a	b	c	d	e	p	t	v	w	h	q	l	k	f
Оператор	i	i	m	n	s	x	a	b	c	d	e	p	t	v	w	h	q	l	k	f	g
Оператор	m	m	n	s	x	a	b	c	d	e	p	t	v	w	h	q	l	k	f	g	i
Оператор	n	n	s	x	a	b	c	d	e	p	t	v	w	h	q	l	k	f	g	i	m
Символ s		s	x	a	b	c	d	e	p	t	v	w	h	q	l	k	f	g	i	m	n
Символ x		x	a	b	c	d	e	p	t	v	w	h	q	l	k	f	g	i	m	n	s

How it works. Examples of shifting the functionality of symbols:

For example, if STP=1 and the symbol m appears in the program code, then we select the mapping between the "Operator m" row and the "STP=1" column. This means that the symbol m will perform the function of the operator n.

For example, if STP=3 and the symbol m appears in the program code, then we select the mapping between the "Operator m" row and the "STP=3" column. This means that the symbol m will perform the function of the operator x.
Moreover, the control symbol x initially has a different length ("x" is two characters long—the "x" itself and the parameter) than the operator "m" (three characters—the "m" itself and two parameters). In this case, the entry "mcb" in the code should perform the function of "xc" (the remaining symbol "b" is discarded as an error, since the functionality of the original "x" does not include a second parameter).

The shift in functionality is performed after the execution of each operator. That is, The code entry fcdgbemc... should be considered as fcd(shift)gbe(shift)mc(shift)...

Errors: If after rotation, an operator receives an inappropriate arity, the operation is skipped.

Period: With STP=1, the rotation period for the Oflameron language version 1.50 is 20 operators. This means that with STP=20, the functionality of the symbols will not change in any way.

Examples of execution with rotation:
Example 1 (STP=1):

text
Source code: fbcgde
Step 1: fbc is performed as a multiplication (b*c = 1*3 = 3, h=3)
Rotation: all characters are shifted right by 1
Step 2: gde is now performed as a subtraction (g is now the i function)
Calculation: |d - e| = |5 - 7| = 2, h=2
Rotation: shift by 1 again
Example 2 (STP=2):

text
Source code: fbc
Step 1: fbc is performed as a multiplication (1*3=3, h=3)
Rotation: shift by 2 positions
Now: a>c(3), b>d(5), c>e(7), f>i(subtraction), etc.

Operators (before rotation):
fXY - multiplication: h = normalize(X * Y) (k+3) - operator size = 3 characters

gXY - addition: h = normalize(X + Y) (k+3) - operator size = 3 characters

iXY - subtraction: h = normalize(Math.abs(X - Y)) (k+3) - operator size = 3 characters

lX - store the ASCII code of the character at position k + normalize(X) (k+2) in l - operator size = 2 characters. The exact character from the "cleaned" program string is read (i.e., a constant, variable, or operator without any extra characters).

mX - print the character with the normalize(X) code to the screen (show the result) (k+2) - operator size = 2 characters

nq - replace the character at position k + normalize(q) with the character with the normalize(h) code (k+2) - operator size = 2 characters. The symbol is replaced in the "cleaned" program code.

General rules:
Execution is strictly left-to-right.

k (the position indicator in the program line on Oflameron) - only increments from 0 to the end of the program line.

Code movement:

f,g,i: k+3

l,m,nq: k+2

Error/unknown symbol: k+1 (simply shift right one position in the program line).

Error: if an operand is expected, but the symbol is invalid > k+1.

Unknown symbols: skipped (k+1).

Self-modification: via the nq operator.

Explanation:

Oflameron program code can be "diluted" with any symbols not included in the SYMBOL_ORDER = ['a','b','c','d','e','p','t','v','w','h','q','l','k','f','g','i','m','n','s','x'] list.
All other symbols are "filler" and, before executing the code in the Translator, such "filler" program code is "cleaned" (the filler symbols are removed).

Example:

1. The program code is fcdfhdghdihbmhghdghdghdghdghcmhghcghcmhihdihdihbmhghcghcghcghcmhihdihcmhgheghdghbmhihcmhihbmh
2. It can be written in another form: f(cdfhdghd)*ihbm.hgh/dghdgh=dghdgh12cmhghc-ghcmh**ihdih{dihbmhghcghc}ghcg-hc#mhihdi$$hcmhghe&ghdghbmhihcmhihbmh
This is simply one type of obfuscation.

If the Translator "cleans" text 2 of unnecessary characters, the result is the same program code 1 in the Oflameron language.

When compiling a program, all operator actions (extracting a character or replacing a character in a string) are performed on the "cleaned" code. The code is "diluted" with deadweight characters only after the program string has been fully developed. This obfuscation is the final step.



Now the task:

Encode the text "Mission Oflameron" in the Offlameron language. STP=0. Add deadweight characters to the program code so that it resembles a long mathematical equation rather than program code.

https://t.me/llmsource/435

-------------------------------------------------------------- Example program --------------------------------------------------------------------------------------

AI Generated Program Example

(i*h*h) + g*a*w - (g*h*d) = i*h*b * m*h ;
(i*h*h) * g*a*w + g*h*v - i*h*p = g*h*d + g*h*c * m*h ;
(i*h*h) - g*a*w * g*h*v = i*h*e / m*h ;
(i*h*h) + g*a*w / g*h*v - i*h*e = m*h ;
(i*h*h) * g*a*w + g*h*v / i*h*p = g*h*d - g*h*c * m*h ;
(i*h*h) - g*a*w + g*h*v = i*h*d * m*h ;
(i*h*h) * g*a*w + g*h*v - i*h*d = i*h*b / m*h ;
(i*h*h) + g*a*w - g*h*v * i*h*c = g*h*c - i*h*b * m*h ;
(i*h*h) - g*a*w + g*h*d * g*h*b = m*h ;
(i*h*h) * g*a*w + g*h*v / i*h*p = g*h*d * m*h ;
(i*h*h) - g*a*w * g*h*v + i*h*p = g*h*e + g*h*c - g*h*b * m*h ;
(i*h*h) + g*a*w - g*h*v = i*h*p / m*h ;
(i*h*h) * g*a*w + g*h*v - i*h*p = g*h*e + g*h*d * m*h ;
(i*h*h) - g*a*w * g*h*v + i*h*p = g*h*d - i*h*b * m*h ;
(i*h*h) + g*a*w / g*h*v - i*h*p = g*h*e + g*h*e - g*h*c * m*h ;
(i*h*h) * g*a*w + g*h*v = i*h*d / m*h ;
(i*h*h) - g*a*w * g*h*v + i*h*d = i*h*b * m*h ;

Program code without ballast symbols

ihhgawghdihbmhihhgawghvihpghdghcmhihhgawghvihemhihhgawghvihemhihhgawghvihpghdghcmhihhgawghvihdmhihhgawghvihdihbmhihhgawghvihcghcihbmhihhgawghdghbmhihhgawghvihpghdmhihhgawghvihpgheghcghbmhihhgawghvihpmhihhgawghvihpgheghdmhihhgawghvihpghdihbmhihhgawghvihpghegheghcmhihhgawghvihdmhihhgawghvihdihbmh



Program code breakdown:

Brief explanation of the structure (for verification):
M (77) → ihh gaw ghd ihb mh
ihh (h = |h-h| = 0) → gaw (h = 73) → ghd (h = 78) → ihb (h = 77) → mh (output 'M')

i (105) → ihh gaw ghv ihp ghd ghc mh
ihh (0) → gaw (73) → ghv (116) → ihp (97) → ghd (102) → ghc (105) → mh

s (115) → ihh gaw ghv ihe mh
ihh (0) → gaw (73) → ghv (116) → ihe (115) → mh

s (115) → repeat
ihh gaw ghv ihe mh

i (105) → repeat
ihh gaw ghv ihp ghd ghc mh

o (111) → ihh gaw ghv ihd mh
ihh (0) → gaw (73) → ghv (116) → ihd (111) → mh

n (110) → ihh gaw ghv ihd ihb mh
ihh (0) → gaw (73) → ghv (116) → ihd (111) → ihb (110) → mh

space (32) → ihh gaw ihv ghc ihb mh
ihh (0) → gaw (73) → ihv (30) → ghc (33) → ihb (32) → mh

O (79) → ihh gaw ghd ghb mh
ihh (0) → gaw (73) → ghd (78) → ghb (79) → mh

f (102) → ihh gaw ghv ihp ghd mh
ihh (0) → gaw (73) → ghv (116) → ihp (97) → ghd (102) → mh

l (108) → ihh gaw ghv ihp ghe ghc ghb mh
ihh (0) → gaw (73) → ghv (116) → ihp (97) → ghe (104) → ghc (107) → ghb (108) → mh

a (97) → ihh gaw ghv ihp mh
ihh (0) → gaw (73) → ghv (116) → ihp (97) → mh

m (109) → ihh gaw ghv ihp ghe ghd mh
ihh (0) → gaw (73) → ghv (116) → ihp (97) → ghe (104) → ghd (109) → mh

e (101) → ihh gaw ghv ihp ghd ihb mh
ihh (0) → gaw (73) → ghv (116) → ihp (97) → ghd (102) → ihb (101) → mh

r (114) → ihh gaw ghv ihp ghe ghe ghc mh
ihh (0) → gaw (73) → ghv (116) → ihp (97) → ghe (104) → ghe (111) → ghc (114) → mh

o (111) → repeat step 6 → ihh gaw ghv ihd mh

n (110) → repeat step 7 → ihh gaw ghv ihd ihb mh


Result - the phrase "Mission Oflameron" is encoded in the program 

https://oflameron.myfilebase.site/