# EnScript

EnScript is an esoteric programming language invented by User:A mainly based on encrypting data. It was created due to the desire of creating a simple language(4 instructions) that will probably result in complex documents. It is created to make writing an implementation very hard, due to the CHS command.

## Syntax

The language runs inside an infinite loop. If a "9" appears in the beginning of one of the accumulators, then the execution halts.

There are a infinitely of unbounded accumulators, each represented by a series of alphabets in English. All of the are pre-set to 0.

## Commands

They can be written lazily, from 0 to 6, in the order that they are presented.

### ENC

ENC means to encrypt the accumulators. Take `ENC A, b` as an example:

• Assume that the accumulator A was set to `123`, and that the accumulator b was set to `231`;
• Encryption happens on the accumulator A.
• Both accumulators are saved, and it will act as a lookup table. The values inside the accumulator A will be changed to another number according to the lookup table.
• (The lookup table acts like this: according to a value in A, find the same value inside the preserved b. Navigate to the value of the preserved A in the same index, and that number in A gets changed to that corresponding number.)
• For example, 1 will be converted to 3; likewise, A will be changed into `312`.
• All unmapped numbers will map to 0. All repeated numbers in the lookup table will be deleted, and the frontmost one will be recovered.

### CHS

CHS means to chase all of the numbers inside an accumulator. This is the hardest command to implement in this language.

• Chasing a number means to move a number forward inside the accumulator that-number times. Chasing an accumulator means to move all of the numbers inside an accumulator from the lowest number (`0`) to the highest number (`9`) sequentially, without repeating.
• Take `A=123` as an example.
• Value 1 will move forward 1 number. (It will be inserted behind 2.) So, the number will be `213`. 1 will be marked as chased.
• Likewise, 2 will also be moved. It will be moved forward twice, so the number will be `132`.
• 3 will also be chased. It will move forward 1 time (finding that the end of the list is reached), and then it will go to the place before 1. Then, it will go back to where it was.
• Accumulator A "chased" will be `132`.

### REV

This one is simpler. I promise.

• Reverse-cat an accumulator and copy the resulting value to another accumulator. So, `REV A, A`(where A was set to 123) will be `321`.

### INC

• Increment all of the values inside the accumulator by 1, with 10 mapping down to 0, and copy the result to another accumulator. So, the code `INC B, A` will increment A and put it into B. `129`(in A) will be `230`(in B).

### "Syntactic sugars" (convenience operations not in the documentation)

This is not part of the documentation; this is just syntactic sugar for this language just to make sure that the language is usable for writing programs.

#### LDA

• Load a value into the accumulator. `LDA A, 12341234`

#### INP

• Input an accumulator if there is nothing inside the accumulator.

#### OUT

• Output an accumulator.

## Examples

### Hello, world! program

(Fortunately the characters don't contain a "9" in the beginning. Phew!)

```LDA A, 72
OUT A
LDA A, 101
OUT A
LDA A, 108
OUT A
OUT A
LDA A, 111
OUT A
LDA A, 44
OUT A
LDA A, 32
OUT A
LDA A, 119
OUT A
LDA A, 111
OUT A
LDA A, 114
OUT A
LDA A, 108
OUT A
LDA A, 100
OUT A
LDA A, 33
OUT A
LDA A, 9
```

### Exchange 2 accumulators

Make sure that all numbers are unique.

```//Swap A and B
ENC A, B
ENC B, A
ENC A, B
// Halting code here (if neccecary)
```

There is another way without limitations:

```//Swap A and B
REV C, B
REV C, C
REV B, A
REV B, B
REV A, C
REV A, A
```

```INC A
```

### Truth-machine

Please make sure that you have a "9" after your one integer of input!

```INP A
OUT A//19 or 09
LDA Z, 10
ENC A, Z
OUT A
```

Lazily:

```5A 6A 4Z,10 1A,Z 6A
```

```INP A
OUT A
```

## Computational class

It is unknown, but it definitely is more powerful than a FSA.