请根据加密算法对明文进行加密
加密规则:
- 输入:
    - 明文: 仅包含大写字母的字符串，不含标点和空格
- 输出:
    - 密文: 大写字母字符串
- 准备:
    - 25个密码轮，每个密码轮包含26个字母的不同排列
    [
            "ABCEIGDJFVUYMHTQKZOLRXSPWN",
            "ACDEHFIJKTLMOUVYGZNPQXRWSB",
            "ADKOMJUBGEPHSCZINXFYQRTVWL",
            "AEDCBIFGJHLKMRUOQVPTNWYXZS",
            "AFNQUKDOPITJBRHCYSLWEMZVXG",
            "AGPOCIXLURNDYZHWBJSQFKVMET",
            "AHXJEZBNIKPVROGSYDULCFMQTW",
            "AIHPJOBWKCVFZLQERYNSUMGTDX",
            "AJDSKQOIVTZEFHGYUNLPMBXWCR",
            "AKELBDFJGHONMTPRQSVZUXYWIC",
            "ALTMSXVQPNOHUWDIZYCGKRFBEJ",
            "AMNFLHQGCUJTBYPZKXISRDVEWO",
            "ANCJILDHBMKGXUZTSWQYVORPFE",
            "AODWPKJVIUQHZCTXBLEGNYRSMF",
            "APBVHIYKSGUENTCXOWFQDRLJZM",
            "AQJNUBTGIMWZRVLXCSHDEOKFPY",
            "ARMYOFTHEUSZJXDPCWGQIBKLNV",
            "ASDMCNEQBOZPLGVJRKYTFUIWXH",
            "ATOJYLFXNGWHVCMIRBSEKUPDZQ",
            "AUTRZXQLYIOVBPESNHJWMDGFCK",
            "AVNKHRGOXEYBFSJMUDQCLZWTIP",
            "AWVSFDLIEBHKNRJQZGMXPUCOTY",
            "AXKWREVDTUFOYHMLSIQNJCPGBZ",
            "AYJPXMVKBQWUGLOSTECHNZFRID",
            "AZDNBUHYFWJLVGRCQMPSOEXTKI"
        ]
- 加密步骤:
    - 初始选择第1个密码轮
    - 对明文中的每个字符p:
        - 在当前密码轮上找到字符p，用其后一个字符替换得到密文字符
        - 如果当前字符在密码轮末尾，则回到密码轮开头
        - 移动到下一个密码轮处理下一个字符，当到达最后一个密码轮时，返回第一个密码轮继续加密过程

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - Reels

        Reel1:   "ABCEIGDJFVUYMHTQKZOLRXSPWN",
        Reel2:   "ACDEHFIJKTLMOUVYGZNPQXRWSB",
        Reel3:   "ADKOMJUBGEPHSCZINXFYQRTVWL",
        Reel4:   "AEDCBIFGJHLKMRUOQVPTNWYXZS",
        Reel5:   "AFNQUKDOPITJBRHCYSLWEMZVXG",
        Reel6:   "AGPOCIXLURNDYZHWBJSQFKVMET",
        Reel7:    "AHXJEZBNIKPVROGSYDULCFMQTW",
        Reel8:    "AIHPJOBWKCVFZLQERYNSUMGTDX",
        Reel9:    "AJDSKQOIVTZEFHGYUNLPMBXWCR",
        Reel10:   "AKELBDFJGHONMTPRQSVZUXYWIC",
        Reel11:    "ALTMSXVQPNOHUWDIZYCGKRFBEJ",
        Reel12:    "AMNFLHQGCUJTBYPZKXISRDVEWO",
        Reel13:    "ANCJILDHBMKGXUZTSWQYVORPFE",
        Reel14:    "AODWPKJVIUQHZCTXBLEGNYRSMF",
        Reel15:    "APBVHIYKSGUENTCXOWFQDRLJZM",
        Reel16:    "AQJNUBTGIMWZRVLXCSHDEOKFPY",
        Reel17:    "ARMYOFTHEUSZJXDPCWGQIBKLNV",
        Reel18:    "ASDMCNEQBOZPLGVJRKYTFUIWXH",
        Reel19:    "ATOJYLFXNGWHVCMIRBSEKUPDZQ",
        Reel20:    "AUTRZXQLYIOVBPESNHJWMDGFCK",
        Reel21:     "AVNKHRGOXEYBFSJMUDQCLZWTIP",
        Reel22:    "AWVSFDLIEBHKNRJQZGMXPUCOTY",
        Reel23:    "AXKWREVDTUFOYHMLSIQNJCPGBZ",
        Reel24:    "AYJPXMVKBQWUGLOSTECHNZFRID",
        Reel25:    "AZDNBUHYFWJLVGRCQMPSOEXTKI"

- Encryption Steps:
    - Initially select the Reel1.
    - For each character p in the plaintext:
        - Find character p on the Reel and replace it with the next character on the Reel to get the ciphertext character.
        - If the current character is at the end of the Reel, go around to the beginning of the Reel.
        - Move to the next Reel to get the next character. When you reach the last Reel, circle back to the first Reel and continue the encryption process.


请根据加密算法对明文进行加密
加密规则:
    - 输入:
        - 明文: 大写字母字符串,不含标点和空格
    - 输出:
        - 密文: 大写字母字符串
    - 准备:
        - LETTERS = ['J', 'D', 'W', 'O', 'T', 'R', 'A', 'C', 'X', 'Q', 'M', 'F', 'Y', 'E', 'Z', 'G', 'U', 'K', 'P', 'V', 'B', 'S', 'H', 'N', 'L', 'I']
        - 将每个字母与其在LETTERS中的位置关联(从0开始):
            J->0, D->1, W->2, O->3, T->4, R->5, A->6, C->7, X->8, Q->9, M->10, F->11, Y->12, E->13, Z->14, G->15, U->16, K->17, P->18, V->19, B->20, S->21, H->22, N->23, L->24, I->25
        - 初始卡牌序列:
            - 54张卡牌的列表,包括52张花色牌和2张可区分的王牌(A王牌和B王牌)。花色牌按四种花色顺序编号1-52,王牌值为53和54。
            - [9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 53, 26, 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 54, 46, 23, 31, 24, 14, 8, 33, 2, 49, 45, 21]
        - 密钥流算法:
            该算法通过移动卡牌生成密钥流值。算法是确定性的,意味着密钥流值仅取决于卡牌的初始顺序。卡牌组被视为循环数组,允许需要移到底部的卡牌绕到顶部。

            执行以下步骤生成密钥流的一个字符:
            1. 找到A王牌并下移一位。如果是最后一张牌,则成为第二张牌。不能成为第一张牌。
            2. 找到B王牌并下移两位。如果是倒数第二张牌,则绕到第二位。如果是最后一张牌,则成为第三张牌。不能成为第一张牌。
            3. 进行"三切":用王牌作为边界将牌组分成三部分,然后交换顶部和底部。王牌本身及其之间的牌保持不变。
            4. 进行"计数切":检查牌组底牌。如果是王牌(53/54),其值固定为53。从牌组顶部取出该数量的牌,插入到最后一张牌的上方。
            5. 查看顶牌的值。同样,任何王牌计为53。计算该牌下方的位置数,使用该位置的牌值作为下一个密钥流值。如果计算出的牌是王牌,忽略它并重复密钥流算法。
            6. 返回生成的密钥流值
    - 加密步骤:
        - cards=初始卡牌序列
        - 对每个明文字符p:
            - 使用字母表将p转换为对应的位置值x(从0开始)
            - 使用初始卡牌序列为p生成密钥流值y:
                - y, cards = 密钥流算法(cards)
                - 该算法修改卡牌顺序,下次执行使用新顺序
            - 当密钥流值y加到位置值x时,应用模26运算得到z:
                - z=(y+x) % 26
            - 使用LETTERS列表返回对应位置z的字母
            - 将其附加到密文

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - LETTERS = ['J', 'D', 'W', 'O', 'T', 'R', 'A', 'C', 'X', 'Q', 'M', 'F', 'Y',
    'E', 'Z', 'G', 'U', 'K', 'P', 'V', 'B', 'S', 'H', 'N', 'L', 'I']
    - Associate each letter with its position in the LETTERS (starting from 0):

        J -> 0, D -> 1, W -> 2, O -> 3, T -> 4, R -> 5, A -> 6, C -> 7, X -> 8, Q -> 9,
        M -> 10, F -> 11, Y -> 12, E -> 13, Z -> 14, G -> 15, U -> 16, K -> 17, P -> 18,
        V -> 19, B -> 20, S -> 21, H -> 22, N -> 23, L -> 24, I -> 25

    - Initial sequence of cards:
        - A list of 54 numbers, including a randomly shuffled deck consisting of 52 suited cards and two distinguishable jokers known as the A Joker and B Joker. Suited cards are valued sequentially across four suits: Clubs, Diamonds, Hearts, and Spades, with values ranging from 1 to 52, while the jokers are valued 53 and 54.
        - [9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 53, 26, 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 54, 46, 23, 31, 24, 14, 8, 33, 2, 49, 45, 21]
    - **Keystream Algorithm**

        This algorithm generates keystream values by moving cards within a deck. The keystream algorithm is *deterministic*, meaning keystream values depend solely on the initial order of the deck. The deck is treated as a circular array, allowing a card that needs to move below the bottom card to wrap around to the top (in other words, the first card follows the last card).

        For example, starting with:
        9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 53, 26, 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 54, 46, 23, 31, 24, 14, 8, 33, 2, 49, 45, 21

        Perform the following steps to generate a character of the keystream:

        1. Locate card A and move it down by one position. If it's the last card, it becomes the second card. It cannot become the first card. The deck now looks like this:
        9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 26, **53,** 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 54, 46, 23, 31, 24, 14, 8, 33, 2, 49, 45, 21
        2. Locate card B and move it down by two positions. Note, if it's the second last card, it will wrap around to become the second card. If it's the last card, it will become the third card. It cannot become the first card. The deck now looks like this:
        9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 26, **53,** 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 46, 23, **54,** 31, 24, 14, 8, 33, 2, 49, 45, 21
        3. Perform a "triple cut": Divide the deck into three parts, using the jokers as boundaries, then swap the top and bottom parts. The jokers themselves and the cards between them remain unchanged.
        31, 24, 14, 8, 33, 2, 49, 45, 21, **53,** 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 46, 23, **54,** 9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 26
        4. Perform a "count cut": Examine the bottom card of the deck. If it's a joker (53/54), its value remains fixed at 53. Take out that many cards from the top of the deck and insert them just above the last card of the deck.
        29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 46, 23, **54,** 9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, **31, 24, 14, 8, 33, 2, 49, 45, 21,** 53, 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 26
        5. Now, look at the value of the top card. Similarly, any joker counts as 53. Calculate the number of positions below this card, and use that card's value as the next value in the keystream. If the calculated card is a joker, ignore it and repeat the keystream algorithm. In this example, the top card is 29, so the value of the 30th card (i.e., 14) determines the keystream value. (Note that no cards change position in this step; this step only determines the keystream value).
        6. Return the resulting keystream value: 14
- Encryption Steps:
    - cards=Initial sequence of cards
    - For each given plaintext character p:
        - Use the alphabet to convert p to the corresponding positional value x. (starting from 0).
        - Generate a keystream value y for p using the Initial sequence of cards:
            - y, cards = Keystream Algorithm (cards)
            - This algorithm modifies the order of the pile of cards, and the next execution then uses the new order.
        - When the keystream value y is added to the position value x, the mod 26 operation is applied to obtain z:
            - z=(y+x) % 26
        - Use the LETTERS list to return the letter corresponding to position z.
        - Append it to the ciphertext.


**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - encryption_table = {
    'A': '!', 'B': '@', 'C': '#', 'D': '$',
    'E': '%', 'F': '^', 'G': '&', 'H': '*',
    'I': '(', 'J': ')', 'K': '_', 'L': '+',
    'M': '=', 'N': '~', 'O': '?', 'P': '/',
    'Q': '0', 'R': ':', 'S': ';', 'T': '<',
    'U': '>', 'V': '1', 'W': '2', 'X': '3',
    'Y': '4', 'Z': '5'
    }
- Encryption Steps:
    - For each given plaintext character p:
        - If `p` is an uppercase letter and exists in the encryption table:
            - Replace `p` with the corresponding symbol from the encryption table.


请根据加密算法对明文进行加密

加密规则:
- 输入:
    - 明文: 仅包含大写字母的字符串，不含标点和空格
- 输出:
    - 密文: 由逗号分隔的数字序列，例如"y1,y2,..."
- 准备:
    - e: 263
    - n: 299
- 加密步骤:
    - 对明文中的每个字母p:
        - 获取字母p对应的ASCII码的十进制数x
        - 计算x^e mod n作为该字母的密文数字y，这里^表示乘法运算
    - 最后，将所有y用逗号连接形成最终密文

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  A sequence of numbers separated by ,. For example, "y1,y2,…".
- Preparation:
    - e: 263
    - n: 299
- Encryption Steps:
    - For each letter p in the plaintext:
        - Get the decimal number x of the value corresponding to the ascii code of p.
        - Compute x^e mod n as the ciphertext number y for that letter p . Here ^ denotes the multiplication operation.
    - Finally, concatenate all the y's and separate them with commas for the final ciphertext.


请根据加密算法对明文进行加密
加密规则:
输入:
    - 明文: 大写字母字符串，不含标点和空格
    - 密钥: 用于选择替换表的字符串
输出:
    - 密文: 大写字母字符串
准备工作:
    - 密码替换表:
        使用以下13个密码替换表，每个表对应两个字母:
        AB: NOPQRSTUVWXYZABCDEFGHIJKLM
        CD: ZNOPQRSTUVWXYBCDEFGHIJKLMA
        EF: YZNOPQRSTUVWXCDEFGHIJKLMAB
        GH: XYZNOPQRSTUVWDEFGHIJKLMABC
        IJ: WXYZNOPQRSTUVEFGHIJKLMABCD
        KL: VWXYZNOPQRSTUFGHIJKLMABCDE
        MN: UVWXYZNOPQRSTGHIJKLMABCDEF
        OP: TUVWXYZNOPQRSHIJKLMABCDEFG
        QR: STUVWXYZNOPQRIJKLMABCDEFGH
        ST: RSTUVWXYZNOPQJKLMABCDEFGHI
        UV: QRSTUVWXYZNOPKLMABCDEFGHIJ
        WX: PQRSTUVWXYZNOLMABCDEFGHIJK
        YZ: OPQRSTUVWXYZNMABCDEFGHIJKL
    - 标准字母表:
        ABCDEFGHIJKLMNOPQRSTUVWXYZ
加密步骤:
    - 将密钥中的每个字母与明文中的每个字母配对。如果密钥比明文短，重复使用密钥
    - 对于每个明文字符p:
        - 根据与之配对的密钥字母找到对应的密码替换表
        - 在标准字母表中找到p的位置，用密码替换表中相同位置的字母替换它

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
    - Key: The key is a string used to select the alphabets. Each letter in the key will be used to select the corresponding alphabet for encryption or decryption.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - Cipher Alphabets

        Use the following 13 cipher alphabets, each associated with two letters:
        AB: NOPQRSTUVWXYZABCDEFGHIJKLM
        CD: ZNOPQRSTUVWXYBCDEFGHIJKLMA
        EF: YZNOPQRSTUVWXCDEFGHIJKLMAB
        GH: XYZNOPQRSTUVWDEFGHIJKLMABC
        IJ: WXYZNOPQRSTUVEFGHIJKLMABCD
        KL: VWXYZNOPQRSTUFGHIJKLMABCDE
        MN: UVWXYZNOPQRSTGHIJKLMABCDEF
        OP: TUVWXYZNOPQRSHIJKLMABCDEFG
        QR: STUVWXYZNOPQRIJKLMABCDEFGH
        ST: RSTUVWXYZNOPQJKLMABCDEFGHI
        UV: QRSTUVWXYZNOPKLMABCDEFGHIJ
        WX: PQRSTUVWXYZNOLMABCDEFGHIJK
        YZ: OPQRSTUVWXYZNMABCDEFGHIJKL

    - Standard Alphabet
        - ABCDEFGHIJKLMNOPQRSTUVWXYZ
- Encryption Steps:
    - Pair each letter in the key with each letter in the plaintext. If the key is shorter than the plaintext, repeat the key.
    - For each given plaintext character p:
        - Find the corresponding cipher alphabet based on the key letter paired with it. If the key letter is A, mark the choice AB: NOPQRSTUVWXYZABCDEFGHIJKLM
        - Find the position of p in the standard alphabet and replace it with the letter at the same position in the cipher alphabet.


请根据加密算法对明文进行加密
加密规则:
- 输入:
    - 明文: 大写字母字符串，不含标点和空格
- 输出:
    - 密文: 不含标点和空格的字符串
- 准备:
    - 每行最大字符数: 5
- 加密步骤:
    - 行数从1开始计数
    - 明文按特殊方式排列：奇数行从左到右写，偶数行从右到左写，每行最多五个字母
        - 例如，对于明文"LIDAHELLOWORLD"，先从左到右写第一行为LIDAH，然后从右到左写第二行为WOLLE，然后从左到右写第三行为ORLD，写完的全部内容表示如下
        LIDAH
        WOLLE
        ORLD
    - 然后按列读取，每列从上到下读取，每读完一列加一个"#"，读出的内容即为最终密文
        - 例如，上述写好的内容按列读取为LWO#IOR#DLL#ALD#HE#

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  A string without punctuation and spaces.
- Preparation:
    - Maximum number of characters per line: 5
- Encryption Steps:
    - Lines are counted from 1.
    - The plaintext is arranged in a special way: an odd number of lines are written from left to right, and an even number of lines are written from right to left, with a maximum of five letters per line.
        - For example, for the plaintext "LIDAHELLOWORLD", first write the first line, from left to right as LIDAH, and then write the second line, from right to left as WOLLE, and then write the third line, from left to right as ORLD, the entire content of the finished writing is expressed as follows
        LIDAH
        WOLLE
        ORLD
    - Then read by column, each column is read from the top down, each read a column plus a "#", read out the contents of the final ciphertext.
        - For example, the above written content is read as LWO#IOR#DLL#ALD#HE# by column.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
- 输入:
    - 明文: 不含标点和空格的大写字母字符串
- 输出:
    - 密文: 不含标点和空格的大写字母字符串
- 准备:
    - 网格和模板:
        - 准备一个空白网格和一个带孔的模板(栅栏)
        - 使用的模板是:
            ▮ ▮ ▮ ▮
            ▮ ▮ ▯ ▯
            ▮ ▮ ▮ ▯
            ▯ ▮ ▮ ▮
            其中白色的是孔，将模板放在空白网格上，只通过白色孔洞，在网格的对应位置填入字符。
- 加密步骤:
    - 将明文逐个分成16个字母的块(如果明文少于16个长度则为一个块)
    - 对每个块执行以下加密操作:
        - 将带孔的模板放在空白网格上
        - 通过模板中的孔按顺序填入明文字母
        - 模板总共有四个孔，所以填完四个字母后，需要将模板逆时针旋转90度
        - 重复填充可见孔中的明文下一个字母并旋转模板，直到整个网格完全填满。这将执行4次填充+旋转，最终模板会转回原始模板。如果消息不足以填满整个网格，用填充字符(如'#')补充
        - 网格填满后，按行读取网格内容作为该块的加密消息
        - 进入下一个块时，清空网格内容并重做整个填充和旋转操作
    最后，将所有块的加密消息连接在一起作为最终密文。
解密算法:
解密规则:
- 输入:
    - 密文: 不含标点和空格的大写字母字符串
- 输出:
    - 明文: 不含标点和空格的大写字母字符串
- 准备:
    - 网格和模板(与加密相同)
- 解密步骤(与加密步骤完全相反):
    - 将密文逐个分成16个字母的块
    - 对每个块执行以下操作:
        - 将16个字母按行写入填满网格
        - 将带孔的模板放在填满的网格上
        - 读取通过孔可见的字母获得部分明文消息
        - 由于只有四个孔，此时需要将模板逆时针旋转90度读取下一组字母
        - 重复读取步骤四次以获得这块解密消息
    - 连接所有块的解密消息得到最终明文。

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  Uppercase letters  string without punctuation and spaces.
- Preparation:
    - Grid and Template:
        - Prepare a blank grid and a template with holes (fence).
        - The template used is:

            ▮  ▮  ▮  ▮
            ▮  ▮  ▯  ▯
            ▮  ▮  ▮  ▯
            ▯  ▮  ▮  ▮

            Where the white ones are holes, place the template on a blank grid, only through the white holes, and fill in the corresponding positions of the grid with characters.

- Encryption Steps:
    - Divide the plaintext into blocks of 16 letters one by one.(If the plaintext is less than 16 long it is one  block)
        - For example, the plaintext message "LOVEHELLOWORLD" is less than 16 and is one block.
    - For each block, perform the following encryption operation:
        - Place the template with holes on the blank grid.
        - Fill the grid with the letters of the plaintext message in order through the holes in the template.
            - For example, the plaintext is "LOVEHELLOWORLD", through the four holes, after filling in the LOVE grid is

                [['', '', '', ''],
                ['', '', 'L', 'O'],
                ['', '', '', 'V'],
                ['E', '', '', '']]

        - The template has a total of four holes, so after filling out the four letters, it can not be filled out, then you need to rotate the template counterclockwise 90 degrees.
            - For example, after filling in LOVE after rotating the template after the template for:

                ▮  ▯  ▯  ▮
                ▮  ▯  ▮  ▮
                ▮  ▮  ▮  ▮
                ▮  ▮  ▮  ▯

        - Repeat filling the visible holes in the grid with the next letter of the plaintext message and rotating the template until the entire grid is completely filled. This will perform 4 fills + rotations and eventually the template will turn to the original template. If the message is not enough to fill the entire grid, it is made up with filler characters (e.g. '#').
            - For example, if the plain text is "LOVEHELLOWORLD", after several fills and rotations, the final grid will be

                [['L', 'H', 'E', 'O'],
                ['W', 'L', 'L', 'O'],
                ['O', 'R', 'D', 'V'],
                ['E', '#', '#', 'L']]

        - Once the grid is filled, read the contents of the grid line by line as the encrypted message for that block.
        - When moving on to the next block, empty the contents of the grid and redo the entire fill and rotate operation.

        Finally, the encrypted messages of all the blocks are connected together to be the final ciphertext.

 **Decryption Rules:**

- Input:
    - Ciphertext: Uppercase letters  string without punctuation and spaces.
- Output:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Preparation:
    - Grid and Template (Same as encryption)
- Decryption Steps (exact opposite of encryption steps):
    - Divide the ciphertext into blocks of 16 letters one by one.
    - For each block, perform the following operations:
        - Write the 16 letters row by row to fill the grid.
        - Place the template with holes on the filled grid.
        - Read the letters visible through the holes to get a portion of the plaintext message.
        - Since there are only four holes, at this point you need to rotate the template 90 degrees counterclockwise to read the next set of letters.
        - Repeat the reading step four times to get this fast decrypted message.
    - Connecting the decrypted messages of all the blocks gives the final plaintext.


请根据加密算法对明文进行加密

加密规则:
- 输入:
    - 明文: 不含标点和空格的大写字母字符串
- 输出:
    - 密文: 不含标点和空格的字符串
- 准备:
    - 行数: 5
- 加密步骤:
    - 在第一行第一个位置填入第一个明文字母
    - 两种填充方式:
        - 向下填充: 在第一行填入"#"(除去第一列，因为第一个位置已经填入明文字母)，然后从第二行到最后一行(第五行)向下填充明文
        - 向上填充: 从最后一行(第五行)到第二行向上填充明文，然后在第一行填入"#"
    - 对于明文中的每个字母(除了已经填在第一个位置的第一个字母)，先进行向下填充，填满一列，然后转向上填充，再转向下填充，如此交替进行，直到所有字母都被填入
    - 填写完成后，逐行读取，读取每行内容后都添加一个*号，标记行的结束；然后读取第二行内容，依此类推，读取所有行，形成最终密文

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  A string without punctuation and spaces.
- Preparation:
    - Number of lines: 5
- Encryption Steps:
    - Fill in the first plaintext in the first position of the first line.
    - Two ways to fill:
        - Downward Fill: Fill the first row with a "#" (removing the first column, since the first position is already filled with a plaintext letter), then fill the plaintext downwards from the second row to the last row (fifth row).
        - Upwards: the plaintext is filled upwards from the last line (fifth line) to the second line, and then the first line is filled with a "#".
    - For each letter in the plaintext (except the first letter which has been filled in the first position), perform downward padding first, fill one column, then turn to upward padding, then turn to downward padding, and so on alternately, until all the letters have been filled.
        - For example, HELLOWORLD.The content of the five lines after filling is
        H L #
        E R D
        L O
        L W
        O #
    - Filled out, read line by line, first read the contents of the first line, after reading the contents of each line are added a * sign, marking the end of the line; and then read the contents of the second line, and so on, read all the lines, the formation of the final password text.
        H L #
        E R D
        L O
        L W
        O #
        - Read the final cipher text line by line as "HL#*ERD*LO*LW*O#*" (i.e., there must be five *'s in the final cipher text to indicate that there are five lines)


请根据加密算法和解密算法对密码进行解密
加密算法:

加密规则:
- 输入:
    - 明文: 不含标点和空格的大写字母字符串
- 输出:
    - 密文: 不含标点和空格的字符串
- 准备:
    - 行数: 5
- 加密步骤:
    - 在第一行第一个位置填入第一个明文字母
    - 两种填充方式:
        - 向下填充: 在第一行填入"#"(除去第一列，因为第一个位置已经填入明文字母)，然后从第二行到最后一行(第五行)向下填充明文
        - 向上填充: 从最后一行(第五行)到第二行向上填充明文，然后在第一行填入"#"
    - 对于明文中的每个字母(除了已经填在第一个位置的第一个字母)，先进行向下填充，填满一列，然后转向上填充，再转向下填充，如此交替进行，直到所有字母都被填入
    - 填写完成后，逐行读取，读取每行内容后都添加一个*号，标记行的结束；然后读取第二行内容，依此类推，读取所有行，形成最终密文

解密算法:

解密规则:
- 输入:
    - 密文: 不含标点和空格的字符串
- 输出:
    - 明文: 不含标点和空格的大写字母字符串
- 准备:
    - 行数: 5
- 解密步骤:
    - 根据密文中的*(不包括*号)，可以分成五组，依次填入五行。得到恢复的五行数据
    - 然后按照先向下读再向上读交替的方式读取所有列。得到未清理的消息
    - 从未清理的消息中删除#，得到最终明文

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  A string without punctuation and spaces.
- Preparation:
    - Number of lines: 5
- Encryption Steps:
    - Fill in the first plaintext in the first position of the first line.
    - Two ways to fill:
        - Downward Fill: Fill the first row with a "#" (removing the first column, since the first position is already filled with a plaintext letter), then fill the plaintext downwards from the second row to the last row (fifth row).
        - Upwards: the plaintext is filled upwards from the last line (fifth line) to the second line, and then the first line is filled with a "#".
    - For each letter in the plaintext (except the first letter which has been filled in the first position), perform downward padding first, fill one column, then turn to upward padding, then turn to downward padding, and so on alternately, until all the letters have been filled.
        - For example, HELLOWORLD.The content of the five lines after filling is
        H L #
        E R D
        L O
        L W
        O #
    - Filled out, read line by line, first read the contents of the first line, after reading the contents of each line are added a * sign, marking the end of the line; and then read the contents of the second line, and so on, read all the lines, the formation of the final password text.
        H L #
        E R D
        L O
        L W
        O #
        - Read the final cipher text line by line as "HL#*ERD*LO*LW*O#*" (i.e., there must be five *'s in the final cipher text to indicate that there are five lines)

 **Decryption Rules:**

- Input:
    - Ciphertext: A string without punctuation and spaces.
- Output:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Preparation:
    - Number of lines: 5
- Decryption Steps (exact opposite of encryption steps):
    - According to the * in the ciphertext (excluding the * sign), it can be divided into five groups, which are filled into five rows in turn. Get the recovered data in five rows.
        - For example, like "HL#*ERD*LO*LW*O#*" ,according to the division of * and then fill in the five lines to get the recovered five lines of data D:
            H L #
            E R D
            L O
            L W
            O #
    - Then read all the columns alternately according to read down first and then read up. Get the uncleared messages.
        - For example, for the five rows of message D in the previous step, read alternately to get "HELLO#WORL#D"
    - Remove the # from the uncleaned message to get the final plaintext.


请根据加密算法对明文进行加密
加密规则:
- 输入:
    - 明文: 仅包含大写字母的字符串，不含标点和空格
- 输出:
    - 密文: 大写字母字符串
- 准备:
    - 标准字母表: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    - 反转字母表: "ZYXWVUTSRQPONMLKJIHGFEDCBA"
    - 替换字母表: "RFDJUHABCEGIKLMNOPQSTVWXYZ"
- 加密步骤:
    - 对明文中的每个字母p:
    - (1) 使用反转字母表进行反向映射。在标准字母表中找到其位置，并用反转字母表中对应位置的字母替换。例如，A映射为Z，B映射为Y。
    - (2) 将步骤(1)得到的字母在标准字母表顺序中向前移动4位。例如，如果p=A，经过步骤(1)映射为Z，然后Z在标准字母表中向前移动4位得到D。
    - (3) 将步骤(2)得到的字母，在标准字母表中找到其位置，用替换字母表中对应位置的字母替换，得到最终的密文字母。例如，如果经过步骤(2)得到字母D，则映射为J。

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - standard_alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    - reversed_alphabet: "ZYXWVUTSRQPONMLKJIHGFEDCBA"
    - substitution_alphabet: "RFDJUHABCEGIKLMNOPQSTVWXYZ"
- Encryption Steps:
    - For each letter p in the given Plaintext:
    - (1) Use reversed_alphabet for reverse mapping. Find its position in the standard_alphabet and replace it with the letter in the corresponding position in reversed_alphabet. For example, A is mapped to Z and B is mapped to Y.
    - (2) Move the letter obtained in (1) forward 4 places in the standard_alphabet order. For example, if p=A, after (1) is mapped to Z, then Z is shifted forward 4 positions in the standard_alphabet to get D.
    - (3) Replace the letter obtained from (2) by finding its position in standard_alphabet and using the corresponding letter in substitution_alphabet, resulting in the final ciphertext letter. For example, if the letter obtained by going through (2) is D, it is mapped as J.


请根据加密算法对明文进行加密

加密规则:

输入:
- 明文: 大写字母字符串，不含标点和空格
- period: 定义内圈多久旋转一次。周期性表示在加密过程中每处理指定数量的字符后，内圈将根据增量值旋转一次
- increment: 定义内圈每次旋转的字符数。在每个周期结束时，内圈将根据增量值向右旋转相应数量的字符

输出:
- 密文: 大写字母字符串

准备:
- outer_disk = "QWERTYUIOPASDFGHJZXCVBNMKL"
- inner_disk = "JKLZXCVBNMASDFGHJQWERTYUIO"

加密步骤:
- 对明文中的每个字符p:
    - 在外圈找到该字符
    - 用内圈对应位置的字符替换它
    - 每加密period个字符后，将内圈向右旋转increment个字符。例如，将'ZXCVBNMASDFGHJKLQWERTYUIOP'旋转4位得到'BNMASDFGHJKLQWERTYUIOPZXCV'

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
    - period: Defines how often the inner disc rotates. Periodicity indicates that after every number of characters processed in the encryption process, the inner disc will rotate once according to the incremental value.
    - increment: Defines the number of characters the inner disc rotates each time. At the end of each cycle, the inner disc will rotate to the right by the corresponding number of characters based on the increment value. For example, if the increment is 4, the inner disc will rotate 4 characters to the right for each cycle that passes (e.g., 5 characters are processed).
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - outer_disk = "QWERTYUIOPASDFGHJZXCVBNMKL"
    - inner_disk = "JKLZXCVBNMASDFGHJQWERTYUIO"
- Encryption Steps:
    - For each character p in the plaintext:
        - Find the character in the outer_disk.
        - Replace it with the character at the corresponding position on the inner_disk.
        - After encrypting every `period` characters, rotate the inner_disk to the right by `increment` characters.For example, rotating 'ZXCVBNMASDFGHJKLQWERTYUIOP' by 4 gives 'BNMASDFGHJKLQWERTYUIOPZXCV'.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
- 输入:
    - 明文: 不含标点和空格的大写字母字符串
- 输出:
    - 密文: 由逗号分隔的数字序列，例如"y1,y2,..."
- 准备:
    - k_q_x值: 12
- 加密步骤:
    - 对明文中的每个字母p:
        - 获取字母p对应的ASCII码值x
        - 计算x * k_q_x作为该字母对应的密文数字y
    - 最后将所有y值用逗号连接得到最终密文
解密算法:
解密规则:
- 输入:
    - 密文: 由逗号分隔的数字序列，例如"y1,y2,..."
- 输出:
    - 明文: 不含标点和空格的大写字母字符串
- 准备:
    - k_q_x值: 12
- 解密步骤:
    - 对密文中的每个数字c:
        - 计算z = c // k_q_x，其中//表示整数除法运算，返回商的整数部分
        - 根据z对应的ASCII码值找到对应的字母作为明文字母p
    - 最后将所有p连接得到最终明文

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  A sequence of numbers separated by ,. For example, "y1,y2,…".
- Preparation:
    - k_q_x : 12
- Encryption Steps:
    - For each letter p in the plaintext:
        - Get the decimal number x corresponding to the ascii code of p.
        - Calculate x * k_q_x as the number y of ciphertexts for that letter p.
    - Finally, concatenate all y's and separate them with commas to get the final ciphertext.

 **Decryption Rules:**

- Input:
    - Ciphertext: A sequence of numbers separated by ,. For example, "y1,y2,…".
- Output:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Preparation:
    - k_q_x : 12
- Decryption Steps:
    - For each number c in the ciphertext:
        - Compute z = c // k_q_x. where // is used in integer division operations to return the integer part of the quotient (i.e., the result of removing the fractional part).
        - Based on the decimal number represented by z, use ascii to find the corresponding letter as the plaintext letter p.
    - Finally, concatenate all p's to get the final plaintext.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
    - 输入:
        - 明文: 仅包含大写字母的字符串，不含标点符号和空格
    - 输出:
        - 密文: 十六进制字符串（包含小写字母a-e）
    - 准备:
        - 密钥(SHA哈希值)
            - 对"SECRET_KEY"执行SHA-256运算，得到'73ef2a4edd7a7fbf07fd5f6faf99674dc0c25a025fd74c221f4c35849e5c0fb3'
    - 加密步骤:
        - 将明文字符串转换为字节序列（ASCII编码）
        - 使用密钥对每个字节进行异或（XOR）运算加密。重复使用密钥使其长度与明文字节数相同
        - 将加密后的字节序列转换为十六进制字符串作为密文输出
解密算法:
解密规则:
    - 输入:
        - 密文: 十六进制字符串（包含小写字母a-e）
    - 输出:
        - 明文: 仅包含大写字母的字符串，不含标点符号和空格
    - 准备:
        - 密钥（与加密相同，是通过SHA-256获得的哈希值）
    - 解密步骤:
        - 将密文字符串转换为字节序列
        - 使用密钥对每个字节进行异或（XOR）运算解密（解密过程与加密过程相同）
        - 将解密后的字节序列转换为明文字符串

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  Hexadecimal string (and letters a-e in lower case).
- Preparation:
    - Key(SHA hash value)
        - Performing SHA-256 on "SECRET_KEY" results in '73ef2a4edd7a7fbf07fd5f6faf99674dc0c25a025fd74c221f4c35849e5c0fb3'.
- Encryption Steps:
    - Converts a plaintext string into a sequence of bytes (ASCII encoding).
    - Each byte is encrypted with the corresponding byte of the key using a bitwise different-or (XOR) operation. Repeatedly recycle the key so that the key length is the same as the number of plaintext bytes.
    - The encrypted byte sequence is converted to a hexadecimal string for ciphertext output.

 **Decryption Rules:**

- Input:
    - Ciphertext: Hexadecimal string (and letters a-e in lower case).
- Output:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Preparation:
    - Key (Same as encryption,is a hashed hash obtained by SHA_256)
- Decryption Steps:
    - Converts the ciphertext string into a sequence of bytes.
    - Each byte is decrypted (the decryption process is the same as the encryption process) with the corresponding byte of the key using a bitwise different-or (XOR) operation.
    - The decrypted byte sequence is converted to a plaintext string.


请根据加密算法对明文进行加密
加密规则:
- 输入:
    - 明文: 不含标点和空格的大写字母字符串
- 输出:
    - 密文: 不含标点和空格的大写字母字符串
- 准备:
    - 5x5网格(所有行和列号从0开始计数):
        - M Z S D P
        K N F L Q
        G A O X U
        W R Y V C
        B T E H I
        - 位于所有行第一个字母的MKGWB是行首字母
        - 位于所有列最后一个字母的PQUCL是列尾字母
- 加密步骤:
    - 移除明文中的空格、标点和字母J，并将所有字母转换为大写
    - 对明文中的每个字母p:
        - 在网格中找到字母p的位置，然后找到相应的行首和列尾字符
        - 将行首和列尾字符连接成二元组作为该字母p的加密消息
        - 例如，如果字母p是H，它在第4行，行首字符是B；它在第3列，列尾字符是H，所以加密消息是BH

    连接所有加密消息作为最终密文输出

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string without punctuation and spaces.
- Preparation:
    - 5x5 Gird(All row and column numbers are counted from 0.):
        - M Z S D P
        K N F L Q
        G A O X U
        W R Y V C
        B T E H I
        - Located at the first letter of all rows, MKGWB is the row header letter.
        - Located at the last letter of all columns, BTEHI is the bottom column letter.
- Encryption Steps:
    - Remove spaces and punctuation and the letter J from plain text and convert all letters to uppercase.
    - For each letter p in the plaintext.
        - Find the position of the letter p in the grid, and then find the corresponding row header and column footer characters accordingly.
        - Concatenate the row-header and column-bottom characters into a binary as the encrypted message for that letter p.
        - For example, if the letter p is H, it is in the 4th row, and the row header character is B; it is in the 3rd column, and the column bottom character is H, so the encrypted message is BH.

    Concatenate all the encrypted messages for the final ciphertext output.


请根据加密算法对明文进行加密
加密规则:
- 输入:
    - 明文: 仅包含大写字母的字符串，不含标点和空格
- 输出:
    - 密文: 大写字母字符串
- 准备:
    - 仿射字母表 = "XMJQUDONPRGTVBWFAKSHZCYEIL"
    - 将每个字母与其在仿射字母表中的位置关联（从0开始）:
        X->0, M->1, J->2, Q->3, U->4, D->5, O->6, N->7,
        P->8, R->9, G->10, T->11, V->12, B->13, W->14, F->15,
        A->16, K->17, S->18, H->19, Z->20, C->21, Y->22, E->23, I->24, L->25
    - A: 3
    - B: 5
    - A_inv: 9
- 加密步骤:
    - 对于每个明文字符p:
        - 设x为其在仿射字母表中的位置
        - 应用仿射编码函数计算y:
            - y = (Ax + B) mod 26
        - 在仿射字母表中找到位置y对应的字母，形成加密消息

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - affine alphabet = "XMJQUDONPRGTVBWFAKSHZCYEIL"
    - Associate each letter with its position in the affine alphabet (starting from 0):

        X -> 0, M -> 1, J -> 2, Q -> 3, U -> 4, D -> 5, O -> 6, N -> 7,
        P -> 8, R -> 9, G -> 10, T -> 11, V -> 12, B -> 13, W -> 14, F -> 15,
        A -> 16, K -> 17, S -> 18, H -> 19, Z -> 20, C -> 21, Y -> 22, E -> 23, I -> 24, L -> 25

    - A: 3
    - B: 5
    - A_inv: 9
- Encryption Steps:
    - For each given plaintext character p:
        - Let  x  denote its position in the affine alphabet.
        - Apply the affine coding function to compute y:
            - y = (Ax + B) mod 26
        - Find the corresponding letter in the affine alphabet at position  y , forming the encrypted message.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
- 输入:
    - 明文: 仅包含大写字母的字符串，不含标点和空格
- 输出:
    - 密文: 大写字母字符串
- 准备:
    - 25个密码轮，每个密码轮包含26个字母的不同排列
    [
            "ABCEIGDJFVUYMHTQKZOLRXSPWN",
            "ACDEHFIJKTLMOUVYGZNPQXRWSB",
            "ADKOMJUBGEPHSCZINXFYQRTVWL",
            "AEDCBIFGJHLKMRUOQVPTNWYXZS",
            "AFNQUKDOPITJBRHCYSLWEMZVXG",
            "AGPOCIXLURNDYZHWBJSQFKVMET",
            "AHXJEZBNIKPVROGSYDULCFMQTW",
            "AIHPJOBWKCVFZLQERYNSUMGTDX",
            "AJDSKQOIVTZEFHGYUNLPMBXWCR",
            "AKELBDFJGHONMTPRQSVZUXYWIC",
            "ALTMSXVQPNOHUWDIZYCGKRFBEJ",
            "AMNFLHQGCUJTBYPZKXISRDVEWO",
            "ANCJILDHBMKGXUZTSWQYVORPFE",
            "AODWPKJVIUQHZCTXBLEGNYRSMF",
            "APBVHIYKSGUENTCXOWFQDRLJZM",
            "AQJNUBTGIMWZRVLXCSHDEOKFPY",
            "ARMYOFTHEUSZJXDPCWGQIBKLNV",
            "ASDMCNEQBOZPLGVJRKYTFUIWXH",
            "ATOJYLFXNGWHVCMIRBSEKUPDZQ",
            "AUTRZXQLYIOVBPESNHJWMDGFCK",
            "AVNKHRGOXEYBFSJMUDQCLZWTIP",
            "AWVSFDLIEBHKNRJQZGMXPUCOTY",
            "AXKWREVDTUFOYHMLSIQNJCPGBZ",
            "AYJPXMVKBQWUGLOSTECHNZFRID",
            "AZDNBUHYFWJLVGRCQMPSOEXTKI"
        ]
- 加密步骤:
    - 初始选择第1个密码轮
    - 对明文中的每个字符p:
        - 在当前密码轮上找到字符p，用其后一个字符替换得到密文字符
        - 如果当前字符在密码轮末尾，则回到密码轮开头
        - 移动到下一个密码轮处理下一个字符，当到达最后一个密码轮时，返回第一个密码轮继续加密过程
解密算法:
解密规则:
- 输入:
    - 密文: 大写字母字符串
- 输出:
    - 明文: 大写字母字符串
- 准备:
    - 25个密码轮，与加密相同
- 解密步骤(与加密步骤相反):
    - 初始选择第1个密码轮
    - 对密文中的每个字符c:
        - 在当前密码轮上找到字符c，用其前一个字符替换得到明文字符
        - 如果当前字符在密码轮开头，则回到密码轮末尾
        - 移动到下一个密码轮处理下一个字符，当到达最后一个密码轮时，返回第一个密码轮继续解密过程

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - Reels

        Reel1:   "ABCEIGDJFVUYMHTQKZOLRXSPWN",
        Reel2:   "ACDEHFIJKTLMOUVYGZNPQXRWSB",
        Reel3:   "ADKOMJUBGEPHSCZINXFYQRTVWL",
        Reel4:   "AEDCBIFGJHLKMRUOQVPTNWYXZS",
        Reel5:   "AFNQUKDOPITJBRHCYSLWEMZVXG",
        Reel6:   "AGPOCIXLURNDYZHWBJSQFKVMET",
        Reel7:    "AHXJEZBNIKPVROGSYDULCFMQTW",
        Reel8:    "AIHPJOBWKCVFZLQERYNSUMGTDX",
        Reel9:    "AJDSKQOIVTZEFHGYUNLPMBXWCR",
        Reel10:   "AKELBDFJGHONMTPRQSVZUXYWIC",
        Reel11:    "ALTMSXVQPNOHUWDIZYCGKRFBEJ",
        Reel12:    "AMNFLHQGCUJTBYPZKXISRDVEWO",
        Reel13:    "ANCJILDHBMKGXUZTSWQYVORPFE",
        Reel14:    "AODWPKJVIUQHZCTXBLEGNYRSMF",
        Reel15:    "APBVHIYKSGUENTCXOWFQDRLJZM",
        Reel16:    "AQJNUBTGIMWZRVLXCSHDEOKFPY",
        Reel17:    "ARMYOFTHEUSZJXDPCWGQIBKLNV",
        Reel18:    "ASDMCNEQBOZPLGVJRKYTFUIWXH",
        Reel19:    "ATOJYLFXNGWHVCMIRBSEKUPDZQ",
        Reel20:    "AUTRZXQLYIOVBPESNHJWMDGFCK",
        Reel21:     "AVNKHRGOXEYBFSJMUDQCLZWTIP",
        Reel22:    "AWVSFDLIEBHKNRJQZGMXPUCOTY",
        Reel23:    "AXKWREVDTUFOYHMLSIQNJCPGBZ",
        Reel24:    "AYJPXMVKBQWUGLOSTECHNZFRID",
        Reel25:    "AZDNBUHYFWJLVGRCQMPSOEXTKI"

- Encryption Steps:
    - Initially select the Reel1.
    - For each character p in the plaintext:
        - Find character p on the Reel and replace it with the next character on the Reel to get the ciphertext character.
        - If the current character is at the end of the Reel, go around to the beginning of the Reel.
        - Move to the next Reel to get the next character. When you reach the last Reel, circle back to the first Reel and continue the encryption process.

 **Decryption Rules:**

- Input:
    - Ciphertext: Uppercase letters string.
- Output:
    - Plaintext: Uppercase letters string.
- Preparation:
    - Reels (Same as encryption)
- Decryption Steps (exact opposite of encryption steps):
    - Initially select the Reel1.
    - For each character c in the ciphertext:
        - Find character c on the Reel and replace it with the previous character  on the Reel to get the plaintext character.
        - If the current character is at the beginning of the Reel, go around to the end of the Reel.
        - Move to the next Reel to get the next character. When you reach the last Reel, circle back to the first Reel and continue the decryption process.


**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - encryption_table = {
    'A': '!', 'B': '@', 'C': '#', 'D': '$',
    'E': '%', 'F': '^', 'G': '&', 'H': '*',
    'I': '(', 'J': ')', 'K': '_', 'L': '+',
    'M': '=', 'N': '~', 'O': '?', 'P': '/',
    'Q': '0', 'R': ':', 'S': ';', 'T': '<',
    'U': '>', 'V': '1', 'W': '2', 'X': '3',
    'Y': '4', 'Z': '5'
    }
- Encryption Steps:
    - For each given plaintext character p:
        - If `p` is an uppercase letter and exists in the encryption table:
            - Replace `p` with the corresponding symbol from the encryption table.

 **Decryption Rules:**

- Input:
    - Ciphertext: Uppercase letters string.
- Output:
    - Plaintext: Uppercase letters string.
- Preparation:
    - encryption_table = {
    'A': '!', 'B': '@', 'C': '#', 'D': '$',
    'E': '%', 'F': '^', 'G': '&', 'H': '*',
    'I': '(', 'J': ')', 'K': '_', 'L': '+',
    'M': '=', 'N': '~', 'O': '?', 'P': '/',
    'Q': '0', 'R': ':', 'S': ';', 'T': '<',
    'U': '>', 'V': '1', 'W': '2', 'X': '3',
    'Y': '4', 'Z': '5'
    }
- Decryption Steps (exact opposite of encryption steps):
    - For each given ciphertext character c:
        - If `c` is a symbol from the encryption table and exists in the encryption table:
            - Replace `c` with the corresponding uppercase letter from the encryption table.


请根据加密算法对明文进行加密
加密规则:
- 输入:
    - 明文: 大写字母字符串，不含标点和空格
- 输出:
    - 密文: 大写字母字符串
- 准备:
以下是经过整理后的文字：

---

### 5x5 网格布局

共有四个5x5的字符网格，每个网格代表了不同的排列方式。

1. **网格1 原始网格**

这是最初的字符排列，按照特定顺序组织如下：

```
K L M N O
P R S T U
V W X Y Z
A B C D E
F G H I J
```

2. **网格2 ECHO 网格**

该网格根据"ECHO"这个词进行了重新排列：

```
E C H O A
B D F G I
J K L M N
P R S T U
V W X Y Z
```

3. **网格3 VORTEX 网格**

此网格基于"VORTEX"一词进行了独特的字符重组：

```
V O R T E
X A B C D
F G H I J
K L M N P
S U W Y Z
```

4. **网格4 重复原始网格**

最后一个网格与第一个原始网格完全相同，没有进行任何改变：

```
K L M N O
P R S T U
V W X Y Z
A B C D E
F G H I J
```

每个网格展示了不同主题词下字符的独特排列。
- 加密步骤:
    - 清理明文，移除空格和非字母字符，移除字母Q，转换为大写
    - 如果明文长度为奇数，添加字母'X'使其成为偶数
    - 将处理后的明文分成两个字母一组
    - 对于每组两个字母p1,p2:
        - 在网格1和网格4中找到第一个字母和第二个字母的位置
        - 在网格2和网格3中找到这两个位置对应的字母，用这两个字母作为该组的加密结果
    - 连接所有加密后的字母组形成最终密文

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - Four 5x5 Girds
        - Gird1
            - K  L  M  N  O
            P  R  S  T  U
            V  W  X  Y  Z
            A  B  C  D  E
            F  G  H  I  J
        - Gird2
            - E  C  H  O  A
            B  D  F  G  I
            J  K  L  M  N
            P  R  S  T  U
            V  W  X  Y  Z
        - Gird3
            - V  O  R  T  E
            X  A  B  C  D
            F  G  H  I  J
            K  L  M  N  P
            S  U  W  Y  Z
        - Gird4
            - K  L  M  N  O
            P  R  S  T  U
            V  W  X  Y  Z
            A  B  C  D  E
            F  G  H  I  J
- Encryption Steps:
    - Cleans up plaintext, removing spaces and non-alphabetic characters, removing the letter Q, and converting all letters to uppercase.
    - If the plaintext is of odd length, add a letter 'X' to make it of even length.
    - Split the cleaned plaintext into two-letter groups.
    - For each double-letter group p1,p2 of the plaintext:
        - In Gird1 and Gird4, find the position of the first letter and the second letter.
        - In Gird2 and Gird3, find the letters corresponding to these two positions, use these two letters as the result of encrypting the double letter combination.
    - Concatenate all the encrypted double letter groups to form the final ciphertext.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
输入:
    - 明文: 大写字母字符串，不含标点和空格
    - 密钥: 用于选择替换表的字符串
输出:
    - 密文: 大写字母字符串
准备工作:
    - 密码替换表:
        使用以下13个密码替换表，每个表对应两个字母:
        AB: NOPQRSTUVWXYZABCDEFGHIJKLM
        CD: ZNOPQRSTUVWXYBCDEFGHIJKLMA
        EF: YZNOPQRSTUVWXCDEFGHIJKLMAB
        GH: XYZNOPQRSTUVWDEFGHIJKLMABC
        IJ: WXYZNOPQRSTUVEFGHIJKLMABCD
        KL: VWXYZNOPQRSTUFGHIJKLMABCDE
        MN: UVWXYZNOPQRSTGHIJKLMABCDEF
        OP: TUVWXYZNOPQRSHIJKLMABCDEFG
        QR: STUVWXYZNOPQRIJKLMABCDEFGH
        ST: RSTUVWXYZNOPQJKLMABCDEFGHI
        UV: QRSTUVWXYZNOPKLMABCDEFGHIJ
        WX: PQRSTUVWXYZNOLMABCDEFGHIJK
        YZ: OPQRSTUVWXYZNMABCDEFGHIJKL
    - 标准字母表:
        ABCDEFGHIJKLMNOPQRSTUVWXYZ
加密步骤:
    - 将密钥中的每个字母与明文中的每个字母配对。如果密钥比明文短，重复使用密钥
    - 对于每个明文字符p:
        - 根据与之配对的密钥字母找到对应的密码替换表
        - 在标准字母表中找到p的位置，用密码替换表中相同位置的字母替换它
解密算法:
解密规则:
输入:
    - 密文: 大写字母字符串
    - 密钥: 用于选择替换表的字符串
输出:
    - 明文: 大写字母字符串
准备工作:
    - 密码替换表: (与加密相同)
    - 标准字母表: (与加密相同)
解密步骤:
    - 将密钥中的每个字母与密文中的每个字母配对。如果密钥比密文短，重复使用密钥
    - 对于每个密文字符c:
        - 根据与之配对的密钥字母找到对应的密码替换表
        - 在密码替换表中找到c的位置，用标准字母表中相同位置的字母还原它

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
    - Key: The key is a string used to select the alphabets. Each letter in the key will be used to select the corresponding alphabet for encryption or decryption.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - Cipher Alphabets

        Use the following 13 cipher alphabets, each associated with two letters:
        AB: NOPQRSTUVWXYZABCDEFGHIJKLM
        CD: ZNOPQRSTUVWXYBCDEFGHIJKLMA
        EF: YZNOPQRSTUVWXCDEFGHIJKLMAB
        GH: XYZNOPQRSTUVWDEFGHIJKLMABC
        IJ: WXYZNOPQRSTUVEFGHIJKLMABCD
        KL: VWXYZNOPQRSTUFGHIJKLMABCDE
        MN: UVWXYZNOPQRSTGHIJKLMABCDEF
        OP: TUVWXYZNOPQRSHIJKLMABCDEFG
        QR: STUVWXYZNOPQRIJKLMABCDEFGH
        ST: RSTUVWXYZNOPQJKLMABCDEFGHI
        UV: QRSTUVWXYZNOPKLMABCDEFGHIJ
        WX: PQRSTUVWXYZNOLMABCDEFGHIJK
        YZ: OPQRSTUVWXYZNMABCDEFGHIJKL

    - Standard Alphabet
        - ABCDEFGHIJKLMNOPQRSTUVWXYZ
- Encryption Steps:
    - Pair each letter in the key with each letter in the plaintext. If the key is shorter than the plaintext, repeat the key.
    - For each given plaintext character p:
        - Find the corresponding cipher alphabet based on the key letter paired with it. If the key letter is A, mark the choice AB: NOPQRSTUVWXYZABCDEFGHIJKLM
        - Find the position of p in the standard alphabet and replace it with the letter at the same position in the cipher alphabet.

 **Decryption Rules:**

- Input:
    - Ciphertext: Uppercase letters string.
    - Key: The key is a string used to select the alphabets. Each letter in the key will be used to select the corresponding alphabet for encryption or decryption.
- Output:
    - Plaintext: Uppercase letters string.
- Preparation:
    - Cipher Alphabets (Same as encryption)
    - Standard Alphabet(Same as encryption)
- Decryption Steps (exact opposite of encryption steps):
    - Pair each letter in the key with each letter in the ciphertext. If the key is shorter than the plaintext, repeat the key.
    - For each given ciphertext character c:
        - Find the corresponding cipher alphabet based on the key letter paired with it. If the key letter is A, mark AB Option: NOPQRSTUVWXYZABCDEFGHIJKLM
        - Find the position of c in the cipher alphabet and reduce it to the plaintext letter using the same position in the standard alphabet.


请根据加密算法对明文进行加密
加密规则:
- 输入:
    - 明文: 不含标点和空格的大写字母字符串
- 输出:
    - 密文: 不含标点和空格的大写字母字符串
- 准备:
    - 网格和模板:
        - 准备一个空白网格和一个带孔的模板(栅栏)
        - 使用的模板是:
            ▮ ▮ ▮ ▮
            ▮ ▮ ▯ ▯
            ▮ ▮ ▮ ▯
            ▯ ▮ ▮ ▮
            其中白色的是孔，将模板放在空白网格上，只通过白色孔洞，在网格的对应位置填入字符。
- 加密步骤:
    - 将明文逐个分成16个字母的块(如果明文少于16个长度则为一个块)
    - 对每个块执行以下加密操作:
        - 将带孔的模板放在空白网格上
        - 通过模板中的孔按顺序填入明文字母
        - 模板总共有四个孔，所以填完四个字母后，需要将模板逆时针旋转90度
        - 重复填充可见孔中的明文下一个字母并旋转模板，直到整个网格完全填满。这将执行4次填充+旋转，最终模板会转回原始模板。如果消息不足以填满整个网格，用填充字符(如'#')补充
        - 网格填满后，按行读取网格内容作为该块的加密消息
        - 进入下一个块时，清空网格内容并重做整个填充和旋转操作
    最后，将所有块的加密消息连接在一起作为最终密文。

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  Uppercase letters  string without punctuation and spaces.
- Preparation:
    - Grid and Template:
        - Prepare a blank grid and a template with holes (fence).
        - The template used is:

            ▮  ▮  ▮  ▮
            ▮  ▮  ▯  ▯
            ▮  ▮  ▮  ▯
            ▯  ▮  ▮  ▮

            Where the white ones are holes, place the template on a blank grid, only through the white holes, and fill in the corresponding positions of the grid with characters.

- Encryption Steps:
    - Divide the plaintext into blocks of 16 letters one by one.(If the plaintext is less than 16 long it is one  block)
        - For example, the plaintext message "LOVEHELLOWORLD" is less than 16 and is one block.
    - For each block, perform the following encryption operation:
        - Place the template with holes on the blank grid.
        - Fill the grid with the letters of the plaintext message in order through the holes in the template.
            - For example, the plaintext is "LOVEHELLOWORLD", through the four holes, after filling in the LOVE grid is

                [['', '', '', ''],
                ['', '', 'L', 'O'],
                ['', '', '', 'V'],
                ['E', '', '', '']]

        - The template has a total of four holes, so after filling out the four letters, it can not be filled out, then you need to rotate the template counterclockwise 90 degrees.
            - For example, after filling in LOVE after rotating the template after the template for:

                ▮  ▯  ▯  ▮
                ▮  ▯  ▮  ▮
                ▮  ▮  ▮  ▮
                ▮  ▮  ▮  ▯

        - Repeat filling the visible holes in the grid with the next letter of the plaintext message and rotating the template until the entire grid is completely filled. This will perform 4 fills + rotations and eventually the template will turn to the original template. If the message is not enough to fill the entire grid, it is made up with filler characters (e.g. '#').
            - For example, if the plain text is "LOVEHELLOWORLD", after several fills and rotations, the final grid will be

                [['L', 'H', 'E', 'O'],
                ['W', 'L', 'L', 'O'],
                ['O', 'R', 'D', 'V'],
                ['E', '#', '#', 'L']]

        - Once the grid is filled, read the contents of the grid line by line as the encrypted message for that block.
        - When moving on to the next block, empty the contents of the grid and redo the entire fill and rotate operation.

        Finally, the encrypted messages of all the blocks are connected together to be the final ciphertext.


请根据加密算法和解密算法对密码进行解密
加密算法:

加密规则:
- 输入:
    - 明文: 仅包含大写字母的字符串，不含标点和空格。
- 输出:
    - 密文: 不含标点的字符串。
- 准备:
    - 多击编码表
        | 字母 | 多击编码 |
        | A | 2^1 |
        | B | 2^2 |
        | C | 2^3 |
        | D | 3^1 |
        | E | 3^2 |
        | F | 3^3 |
        | G | 4^1 |
        | H | 4^2 |
        | I | 4^3 |
        | J | 5^1 |
        | K | 5^2 |
        | L | 5^3 |
        | M | 6^1 |
        | N | 6^2 |
        | O | 6^3 |
        | P | 7^1 |
        | Q | 7^2 |
        | R | 7^3 |
        | S | 7^4 |
        | T | 8^1 |
        | U | 8^2 |
        | V | 8^3 |
        | W | 9^1 |
        | X | 9^2 |
        | Y | 9^3 |
        | Z | 9^4 |
- 加密步骤:
    - 对于每个明文字符p:
        - 如果p是大写字母且存在于多击编码表中:
            - 用多击编码表中对应的多击编码替换p。

解密算法:

解密规则:
- 输入:
    - 密文: 不含标点的字符串。
- 输出:
    - 明文: 大写字母字符串。
- 准备: 多击编码表(与加密相同)
- 解密步骤(与加密步骤相反):
    - 对于每个密文中的多击编码c:
        - 如果c是多击编码表中的编码:
            - 用多击编码表中对应的大写字母替换c。

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: A string without punctuation.
- Preparation:
    - Multitap Code Table
        | Letter | Multitap Code |
        | --- | --- |
        | A | 2^1 |
        | B | 2^2 |
        | C | 2^3 |
        | D | 3^1 |
        | E | 3^2 |
        | F | 3^3 |
        | G | 4^1 |
        | H | 4^2 |
        | I | 4^3 |
        | J | 5^1 |
        | K | 5^2 |
        | L | 5^3 |
        | M | 6^1 |
        | N | 6^2 |
        | O | 6^3 |
        | P | 7^1 |
        | Q | 7^2 |
        | R | 7^3 |
        | S | 7^4 |
        | T | 8^1 |
        | U | 8^2 |
        | V | 8^3 |
        | W | 9^1 |
        | X | 9^2 |
        | Y | 9^3 |
        | Z | 9^4 |
- Encryption Steps:
    - For each given plaintext character p:
        - If `p` is an uppercase letter and exists in the Multitap Code Table:
            - Replace `p` with the corresponding Multitap Code from the Multitap Code Table.

 **Decryption Rules:**

- Input:
    - Ciphertext: A string without punctuation.
- Output:
    - Plaintext: Uppercase letters string.
- Preparation: Multitap Code Table (Same as encryption)
- Decryption Steps (exact opposite of encryption steps):
    - For each given ciphertext Multitap Code c:
        - If `c` is a Multitap Code from the Multitap Code Table:
            - Replace `c` with the corresponding uppercase letter from the Multitap Code Table.


请根据加密算法和解密算法对密码进行解密
加密算法:

加密规则:
- 输入:
    - 明文: 大写字母字符串，不含标点和空格
- 输出:
    - 密文: 字符串
- 准备:
    - 数字索引映射表
        - '..' : 5
        - '.-' : 4
        - './' : 9
        - '-.' : 8
        - '--' : 6
        - '-/' : 7
        - '/.' : 3
        - '/-' : 1
        - '//' : 2
    - 摩斯密码表
        - A: '.-',     B: '-...',   C: '-.-.',   D: '-..',
        - E: '.',      F: '..-.',   G: '--.',    H: '....',
        - I: '..',     J: '.---',   K: '-.-',    L: '.-..',
        - M: '--',     N: '-.',     O: '---',    P: '.--.',
        - Q: '--.-',   R: '.-.',    S: '...',    T: '-',
        - U: '..-',    V: '...-',   W: '.--',    X: '-..-',
        - Y: '-.--',   Z: '--..'
- 加密步骤:
    - 根据摩斯密码表将明文中的每个字符转换为摩斯密码，用/分隔每个字符，例如AB对应'.-/-...'
    - 将摩斯密码分成两个字符一组。如果摩斯密码长度为奇数，最后一个字符不进行映射，直接添加到密文末尾
    - 根据数字索引映射表将每组字符转换为对应的数字字符串
    - 加密后的消息用字符串表示

解密算法:

解密规则:
- 输入:
    - 密文: 数字字符串
- 输出:
    - 明文: 大写字母字符串
- 准备:
    - 数字索引映射表(与加密相同)
    - 摩斯密码表(与加密相同)
- 解密步骤(与加密步骤相反):
    - 根据数字索引映射表将密文中的每个数字转换为对应的字符对。如果密文末尾有非数字字符，则不处理。此时获得完整的摩斯密码
    - 通过/分隔摩斯密码获得每个字符的摩斯密码
    - 根据摩斯密码表将每个字符的摩斯密码转换为对应的明文字符
    - 最终明文字符为大写字符串

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: A string.
- Preparation:
    - Numerical-Index Mapping Table
        - '..' : 5
        - '.-' : 4
        - './' : 9
        - '-.' : 8
        - '--' : 6
        - '-/' : 7
        - '/.' : 3
        - '/-' : 1
        - '//' : 2
    - morse_code Table
        - morse_code = {
                'A': '.-',     'B': '-...',   'C': '-.-.',   'D': '-..',
                'E': '.',      'F': '..-.',   'G': '--.',    'H': '....',
                'I': '..',     'J': '.---',   'K': '-.-',    'L': '.-..',
                'M': '--',     'N': '-.',     'O': '---',    'P': '.--.',
                'Q': '--.-',   'R': '.-.',    'S': '...',    'T': '-',
                'U': '..-',    'V': '...-',   'W': '.--',    'X': '-..-',
                'Y': '-.--',   'Z': '--..',
            }
- Encryption Steps:
    - Convert each character in the plaintext into Morse code according to the morse_code Table, with each character separated by a /, e.g., the Morse code corresponding to AB is '.-/-...'.
    - Divide Morse code into two pairs of characters. If the length of the Morse code is odd, the last character, without the following mapping, is finally added to the end of the ciphertext.
    - Each pair of characters is converted into a corresponding numeric string according to the numeric index mapping table.
    - The encrypted message is represented by a string.

 **Decryption Rules:**

- Input:
    - Ciphertext: A numeric string.
- Output:
    - Plaintext: Uppercase letters string.
- Preparation:
    - Numerical-Index Mapping Table (Same as encryption)
    - morse_code Table (Same as encryption)
- Decryption Steps (exact opposite of encryption steps):
    - Each digit in the ciphertext is converted to the corresponding character pair according to the digit-index mapping table. If there is a non-numeric character at the end of the ciphertext, it is not processed. By this point, the complete Morse code is obtained.
    - Obtain the Morse code for each character by splitting the Morse code by /.
    - Convert the Morse code of each character to the corresponding plaintext character according to the morse_code table.
    - The final plaintext character is an uppercase string.


请根据加密算法对明文进行加密
加密规则:
- 输入:
    - 明文: 不含标点和空格的大写字母字符串
- 输出:
    - 密文: 大写字母字符串
- 准备:
    - 字母表 = 'ABCDEFGHIKLMNOPQRSTUVWXYZ'(不包含字母J)
    - 8个网格(Grid0-Grid7)
- 加密步骤:
    - 明文按5个字符分组，从0开始编号
    - 对于5个字符的块:
        - 使用的网格由grid_index = (i // 5) % 8确定，其中i是块号。整数除法运算符//将左边的数除以右边的数，向下取整结果
        - 对于当前块中的每个字符:
            - 如果字符是"J"，不加密直接添加到加密块
            - 否则，在当前网格中找到字符的位置。然后向右下方移动一个网格位置(row+1,col+1)(如果越界则在对应边界的另一侧继续)，移动后位置的字母作为加密字母
            - 将加密字母添加到加密块
    - 处理完所有块后，连接加密块形成最终加密消息

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - alphabet = 'ABCDEFGHIKLMNOPQRSTUVWXYZ'(The letter J is excluded)
    - 8 Grids:

        Grid0:

        | P | H | I | L | S |
        | A | B | C | D | E |
        | F | G | K | M | N |
        | O | Q | R | T | U |
        | V | W | X | Y | Z |

        Grid1:

        | V | W | X | Y | Z |
        | P | H | I | L | S |
        | A | B | C | D | E |
        | F | G | K | M | N |
        | O | Q | R | T | U |

        Grid2:

        | O | Q | R | T | U |
        | V | W | X | Y | Z |
        | P | H | I | L | S |
        | A | B | C | D | E |
        | F | G | K | M | N |

        Grid3:

        | F | G | K | M | N |
        | O | Q | R | T | U |
        | V | W | X | Y | Z |
        | P | H | I | L | S |
        | A | B | C | D | E |

        Grid4:

        | A | B | C | D | E |
        | F | G | K | M | N |
        | O | Q | R | T | U |
        | V | W | X | Y | Z |
        | P | H | I | L | S |

        Grid5:

        | P | H | I | L | S |
        | A | B | C | D | E |
        | F | G | K | M | N |
        | O | Q | R | T | U |
        | V | W | X | Y | Z |

        Grid6:

        | V | W | X | Y | Z |
        | P | H | I | L | S |
        | A | B | C | D | E |
        | F | G | K | M | N |
        | O | Q | R | T | U |

        Grid7:

        | O | Q | R | T | U |
        | V | W | X | Y | Z |
        | P | H | I | L | S |
        | A | B | C | D | E |
        | F | G | K | M | N |

- Encryption Steps:
    - The plaintext is grouped into blocks of 5 characters, numbered from 0.
    - For blocks of 5 characters:
        - To use the grid is determined by calculating grid_index = (i // 5) % 8, where i is the number. Integer division operator // divides the number on the left by the number on the right, rounding down the result. That is, it removes the fractional part and keeps only the integer part!This ensures that the grid is recycled.
        - For each character in the current block:
            - If the character is "J", it is not encrypted and is appended directly to the encrypted block.
            - Otherwise, find the position of the character in the current grid. Then move one grid position to the lower right (row+1,col+1) (or continue on the opposite side of the corresponding boundary if it crosses the boundary), and get the letter at the position after the move as the encrypted letter.
            - Add the encrypted letter to the encryption block.
    - After processing all the blocks, connect the encrypted blocks to form the final encrypted message.


请根据加密算法对明文进行加密
加密规则:
    - 输入:
        - 明文: 仅包含大写字母的字符串，不含标点符号和空格
    - 输出:
        - 密文: 十六进制字符串（包含小写字母a-e）
    - 准备:
        - 密钥(SHA哈希值)
            - 对"SECRET_KEY"执行SHA-256运算，得到'73ef2a4edd7a7fbf07fd5f6faf99674dc0c25a025fd74c221f4c35849e5c0fb3'
    - 加密步骤:
        - 将明文字符串转换为字节序列（ASCII编码）
        - 使用密钥对每个字节进行异或（XOR）运算加密。重复使用密钥使其长度与明文字节数相同
        - 将加密后的字节序列转换为十六进制字符串作为密文输出

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  Hexadecimal string (and letters a-e in lower case).
- Preparation:
    - Key(SHA hash value)
        - Performing SHA-256 on "SECRET_KEY" results in '73ef2a4edd7a7fbf07fd5f6faf99674dc0c25a025fd74c221f4c35849e5c0fb3'.
- Encryption Steps:
    - Converts a plaintext string into a sequence of bytes (ASCII encoding).
    - Each byte is encrypted with the corresponding byte of the key using a bitwise different-or (XOR) operation. Repeatedly recycle the key so that the key length is the same as the number of plaintext bytes.
    - The encrypted byte sequence is converted to a hexadecimal string for ciphertext output.


请根据加密算法对明文进行加密
加密规则:
    - 输入:
        - 明文: 不含标点和空格的大写字母字符串
    - 输出:
        - 密文: 不含标点和空格的字符串
    - 准备:
        - 转置序列表:
            - [1, 4, 0, 6, 5, 2, 3]
            - 转置序列表用于按顺序逐行写入明文，然后根据转置序列表调整列的顺序，使每行中的字符按给定顺序排列。
            - 列从0开始计数。
    - 加密步骤:
        - [1, 4, 0, 6, 5, 2, 3]转置序列表共7位，表示一行应写入7个字母。
        - 按顺序逐行写入明文，每行7个。当不足7个时，最后一行用$填充。可以得到一个写入网格。
        - 根据转置序列表调整列的顺序，即现在列的顺序为[原列1，原列4，原列0，原列6，原列5，原列2，原列3]，可以得到调整列顺序后的网格。
        - 逐行读取网格并连接起来得到最终密文。(注意需要保留$)

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  A string without punctuation and spaces.
- Preparation:
    - Transposed sequence list:
        - [1, 4, 0, 6, 5, 2, 3]
        - The transposed sequence  list is used to write the plaintext in order one line at a time, and then the columns are adjusted according to the transposed sequence table so that the characters in each line are arranged in the given order.
        - Columns count from 0.
- Encryption Steps:
    - The [1, 4, 0, 6, 5, 2, 3] transposed sequence table has a total of 7 bits, indicating that 7 letters should be written on a line.
    - Write the plaintext in order, line by line, 7 per line. When there are less than 7, the last line is filled with $. A written grid can be obtained.
    - According to the transposed sequence table, adjust the order of the columns, that is, the order of the columns is now [the original column 1, the original column 4, the original column 0, the original column 6, the original column 5, the original column 2, the original column 3], you can get after the adjustment of the columns after the order of the grid.
    - Read the grid row by row and connect them to get the final ciphertext.(Note that $ needs to be retained.)


请根据加密算法和解密算法对密码进行解密
加密算法:

        加密规则:
        - 输入:
            - 明文: 仅包含大写字母(A-Z)的字符串，不含标点和空格
        - 输出:
            - 密文: 仅包含0和1的二进制字符串
        - 准备:
            - 固定密钥: 8位二进制字符串(例如'10101010')
            - 置换表:
                - 置换表: (2, 0, 3, 1, 4, 6, 5, 7)
                - 逆置换表: (1, 3, 0, 2, 4, 6, 5, 7)
        - 加密步骤:
            1. 将每个字符转换为二进制:
                - 将每个字符转换为ASCII值
                - 将ASCII值转换为8位二进制字符串
            2. XOR运算:
                - 对字符的8位二进制表示与固定密钥进行XOR运算
                - 如果需要，重复密钥以匹配二进制表示的长度
            3. 置换:
                - 对XOR结果应用置换表得到每个字符的最终加密二进制字符串
            4. 合并二进制字符串:
                - 将所有字符的二进制字符串连接形成最终密文

解密算法:

        解密规则:
        - 输入:
            - 密文: 仅包含0和1的二进制字符串
        - 输出:
            - 明文: 仅包含大写字母(A-Z)的字符串，不含标点和空格
        - 准备:
            - 固定密钥: 与加密使用的相同8位二进制字符串(例如'10101010')
            - 置换表:
                - 置换表: (2, 0, 3, 1, 4, 6, 5, 7)
                - 逆置换表: (1, 3, 0, 2, 4, 6, 5, 7)
        - 解密步骤:
            1. 将密文分块:
                - 将二进制密文分成8位一组，每组代表一个加密字符
            2. 逆置换:
                - 对每个8位块应用逆置换表以还原加密时的置换
            3. XOR运算:
                - 对置换后的二进制块与固定密钥进行XOR运算
            4. 二进制转字符:
                - 将得到的二进制字符串转换为十进制值
                - 将十进制值转换为对应的ASCII字符
            5. 合并字符:
                - 将每个二进制块得到的字符连接形成最终明文

**Encryption Rules**

- Input:
    - Plaintext: A string of uppercase letters (A-Z) without punctuation and spaces.
- Output:
    - Ciphertext: A binary string containing only 0s and 1s.
- Preparation:
    - Fixed Key: A binary string of length 8 (e.g., '10101010').
    - Permutation Table:
        - Permutation Table: (2, 0, 3, 1, 4, 6, 5, 7)
        - Inverse Permutation Table: (1, 3, 0, 2, 4, 6, 5, 7)
- Encryption Steps:
    1. Convert Each Character to Binary:
        - For each character in the plaintext, convert it to its ASCII value.
        - Convert this ASCII value to an 8-bit binary string.
    2. XOR Operation:
        - Perform an XOR operation between the 8-bit binary representation of the character and the fixed key.
        - Ensure the key is repeated to match the length of the binary representation if needed.
    3. Permutation:
        - Apply the permutation table to the XOR result to get the final encrypted binary string for each character.
    4. Combine Binary Strings:
        - Concatenate the binary strings of all characters to form the final ciphertext.

**Decryption Rules**

- Input:
    - Ciphertext: A binary string containing only 0s and 1s.
- Output:
    - Plaintext: A string of uppercase letters (A-Z) without punctuation and spaces.
- Preparation:
    - Fixed Key: Same binary string of length 8 used for encryption (e.g., '10101010').
    - Permutation Table:
        - Permutation Table: (2, 0, 3, 1, 4, 6, 5, 7)
        - Inverse Permutation Table: (1, 3, 0, 2, 4, 6, 5, 7)
- Decryption Steps:
    1. Split Ciphertext into Chunks:
        - Split the binary ciphertext into 8-bit chunks, each representing an encrypted character.
    2. Inverse Permutation:
        - Apply the inverse permutation table to each 8-bit chunk to reverse the permutation applied during encryption.
    3. XOR Operation:
        - Perform an XOR operation between the permuted binary chunk and the fixed key.
    4. Convert Binary to Character:
        - Convert the resulting binary string back to its decimal equivalent.
        - Convert this decimal value to its corresponding ASCII character.
    5. Combine Characters:
        - Concatenate the characters obtained from each binary chunk to form the final plaintext.


请根据加密算法对明文进行加密

        加密规则:
        - 输入:
            - 明文: 仅包含大写字母(A-Z)的字符串，不含标点和空格
        - 输出:
            - 密文: 仅包含0和1的二进制字符串
        - 准备:
            - 固定密钥: 8位二进制字符串(例如'10101010')
            - 置换表:
                - 置换表: (2, 0, 3, 1, 4, 6, 5, 7)
                - 逆置换表: (1, 3, 0, 2, 4, 6, 5, 7)
        - 加密步骤:
            1. 将每个字符转换为二进制:
                - 将每个字符转换为ASCII值
                - 将ASCII值转换为8位二进制字符串
            2. XOR运算:
                - 对字符的8位二进制表示与固定密钥进行XOR运算
                - 如果需要，重复密钥以匹配二进制表示的长度
            3. 置换:
                - 对XOR结果应用置换表得到每个字符的最终加密二进制字符串
            4. 合并二进制字符串:
                - 将所有字符的二进制字符串连接形成最终密文

**Encryption Rules**

- Input:
    - Plaintext: A string of uppercase letters (A-Z) without punctuation and spaces.
- Output:
    - Ciphertext: A binary string containing only 0s and 1s.
- Preparation:
    - Fixed Key: A binary string of length 8 (e.g., '10101010').
    - Permutation Table:
        - Permutation Table: (2, 0, 3, 1, 4, 6, 5, 7)
        - Inverse Permutation Table: (1, 3, 0, 2, 4, 6, 5, 7)
- Encryption Steps:
    1. Convert Each Character to Binary:
        - For each character in the plaintext, convert it to its ASCII value.
        - Convert this ASCII value to an 8-bit binary string.
    2. XOR Operation:
        - Perform an XOR operation between the 8-bit binary representation of the character and the fixed key.
        - Ensure the key is repeated to match the length of the binary representation if needed.
    3. Permutation:
        - Apply the permutation table to the XOR result to get the final encrypted binary string for each character.
    4. Combine Binary Strings:
        - Concatenate the binary strings of all characters to form the final ciphertext.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
    - 输入:
        - 明文: 不含标点和空格的大写字母字符串
    - 输出:
        - 密文: 不含标点和空格的字符串
    - 准备:
        - 转置序列表:
            - [1, 4, 0, 6, 5, 2, 3]
            - 转置序列表用于按顺序逐行写入明文，然后根据转置序列表调整列的顺序，使每行中的字符按给定顺序排列。
            - 列从0开始计数。
    - 加密步骤:
        - [1, 4, 0, 6, 5, 2, 3]转置序列表共7位，表示一行应写入7个字母。
        - 按顺序逐行写入明文，每行7个。当不足7个时，最后一行用$填充。可以得到一个写入网格。
        - 根据转置序列表调整列的顺序，即现在列的顺序为[原列1，原列4，原列0，原列6，原列5，原列2，原列3]，可以得到调整列顺序后的网格。
        - 逐行读取网格并连接起来得到最终密文。(注意需要保留$)
解密算法:
解密规则:
    - 输入:
        - 密文: 不含标点和空格的字符串
    - 输出:
        - 明文: 不含标点和空格的大写字母字符串
    - 准备:
        - 转置序列表(与加密相同)
    - 解密步骤:
        - 按顺序逐行写入密文，每行7个字母。
        - 逐行读取，但读取每行时，先读取对应0的第2列的字符，然后读取对应1的第0列的字符，然后读取对应2的第6列的字符，依此类推。
        - 最终逐行读取信息，去掉末尾的$，即可得到解密后的明文。

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  A string without punctuation and spaces.
- Preparation:
    - Transposed sequence list:
        - [1, 4, 0, 6, 5, 2, 3]
        - The transposed sequence  list is used to write the plaintext in order one line at a time, and then the columns are adjusted according to the transposed sequence table so that the characters in each line are arranged in the given order.
        - Columns count from 0.
- Encryption Steps:
    - The [1, 4, 0, 6, 5, 2, 3] transposed sequence table has a total of 7 bits, indicating that 7 letters should be written on a line.
    - Write the plaintext in order, line by line, 7 per line. When there are less than 7, the last line is filled with $. A written grid can be obtained.
    - According to the transposed sequence table, adjust the order of the columns, that is, the order of the columns is now [the original column 1, the original column 4, the original column 0, the original column 6, the original column 5, the original column 2, the original column 3], you can get after the adjustment of the columns after the order of the grid.
    - Read the grid row by row and connect them to get the final ciphertext.(Note that $ needs to be retained.)

 **Decryption Rules:**

- Input:
    - Ciphertext: A string without punctuation and spaces.
- Output:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Preparation:
    - Transposed sequence list (Same as encryption)
- Decryption Steps:
    - Write the ciphertext sequentially, line by line, 7 letters per line.
    - Read line by line, but when reading each line, read a character in column 2 corresponding to 0, then a character in column 0 corresponding to 1, then a character in column 6 corresponding to 2, etc., etc., etc., etc., etc., etc.
    - Eventually read the message line by line, remove the $ at the end, you can get the decrypted plaintext.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
- 输入:
    - 明文: 不含标点和空格的大写字母字符串
- 输出:
    - 密文: 不含标点和空格的大写字母字符串
- 准备:
    - 6x6矩阵 (矩阵中的行和列从0开始计数)
        [['R', 'U', 'A', '0', 'Q', 'B'],
        ['D', '2', 'W', 'K', 'S', '1'],
        ['H', '4', '5', 'F', 'T', 'Z'],
        ['Y', 'C', 'G', 'X', '7', 'L'],
        ['9', '8', 'I', '3', 'P', 'N'],
        ['6', 'J', 'V', 'O', 'E', 'M']]
    - 加密字符集: "ADFGVX"
- 加密步骤:
    - 对明文中的每个字符:
        - 在6X6矩阵中找到该字符的行数和列数。例如，A的行数为0，列数为2。
        - 加密字符集中的字符位置标记为0-6。使用加密字符集中对应位置的字符替换行数和列数得到加密二元组。
            - 例如，A的行数为0对应加密字符集中的A，列数为2对应加密字符集中的F，所以A的加密二元组为(A,F)。
        - 读取所有加密二元组的行，然后读取所有加密二元组的列得到最终密文。
            - 例如，加密二元组为(A,F)(X,V)，最后读取为AXFV，所以最终密文为AXFV。
解密算法:
解密规则:
- 输入:
    - 密文: 不含标点和空格的大写字母字符串
- 输出:
    - 明文: 不含标点和空格的大写字母字符串
- 准备:
    - 6x6矩阵 (与加密相同)
    - 加密字符集 (与加密相同)
- 解密步骤:
    - 将密文分成两半
    - 每次从上半部分和下半部分各取一个字母作为解密二元组:
        - 加密字符集中的字符位置标记为0-6，使用加密字符集中对应字符的位置解密出解密二元组代表的行数和列数。
            - 例如，解密二元组为加密二元组(A,F)，A的位置为0，F的位置为2，所以行数为0，列数为2，得到(0,2)。
        - 使用得到的行数和列数在6x6矩阵中找到对应位置的字母作为解密后的字符。
            - 例如，(0,2)位置的字符为A，所以AF解密后的字符为A。
    - 连接所有解密后的字符得到最终明文。

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  Uppercase letters  string without punctuation and spaces.
- Preparation:
    - 6x6 Matrix (The rows and columns in the matrix are counted from 0.)

        [['R', 'U', 'A', '0', 'Q', 'B'],
        ['D', '2', 'W', 'K', 'S', '1'],
        ['H', '4', '5', 'F', 'T', 'Z'],
        ['Y', 'C', 'G', 'X', '7', 'L'],
        ['9', '8', 'I', '3', 'P', 'N'],
        ['6', 'J', 'V', 'O', 'E', 'M']]

    - Encrypted Character Set
        - "ADFGVX"
- Encryption Steps:
    - For each character in the plaintext:
        - Find the number of rows and columns of that character in the 6X6 matrix. For example, A has 0 rows and 2 columns.
        - The position of each character in the encrypted character set is flagged as 0-6. Use the character at the corresponding position in the encrypted character set to replace the number of rows and columns to get the encrypted binary.
            - For example, the number of rows of A is 0, which corresponds to A in the encrypted character set, and the number of columns of A is 2, which corresponds to F in the encrypted character set. so the encrypted binary corresponding to A is (A,F).The encrypted binary is (A,F).
        - Read all rows of the encrypted binary, and then read all columns of the encrypted binary to get the final ciphertext.
            - For example, the encrypted binary is (A,F)(X,V), the last read is AXFV, so the final ciphertext is AXFV.

 **Decryption Rules:**

- Input:
    - Ciphertext: Uppercase letters  string without punctuation and spaces.
- Output:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Preparation:
    - 6x6 Matrix (Same as encryption)
    - Encrypted Character Set (Same as encryption)
- Decryption Steps:
    - Divide the ciphertext into two halves.
    - Take one letter from the upper half and one letter from the lower half each time as a decryption binary:
        - The position of each character in the encrypted character set is flagged as 0-6, and the position of the corresponding character in the encrypted character set is used to decrypt the number of rows and columns represented by the decrypted binary.
            - For example, the decrypted binary is the encrypted binary as (A,F), the position of A is 0 and the position of F is 2, so the number of rows is 0 and the number of columns is 2, obtaining (0, 2).
        - Use the number of rows and columns obtained to find the letter in the corresponding position in the 6x6 matrix as the character after decryption.
            - For example, the character at (0, 2) is A, and the character after AF decryption is A.
    - Concatenate all the decrypted characters to get the final plaintext.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
- 输入:
    - 明文: 仅包含大写字母的字符串，不含标点和空格
- 输出:
    - 密文: 大写字母字符串
- 准备:
    - 仿射字母表 = "XMJQUDONPRGTVBWFAKSHZCYEIL"
    - 将每个字母与其在仿射字母表中的位置关联（从0开始）:
        X->0, M->1, J->2, Q->3, U->4, D->5, O->6, N->7,
        P->8, R->9, G->10, T->11, V->12, B->13, W->14, F->15,
        A->16, K->17, S->18, H->19, Z->20, C->21, Y->22, E->23, I->24, L->25
    - A: 3
    - B: 5
    - A_inv: 9
- 加密步骤:
    - 对于每个明文字符p:
        - 设x为其在仿射字母表中的位置
        - 应用仿射编码函数计算y:
            - y = (Ax + B) mod 26
        - 在仿射字母表中找到位置y对应的字母，形成加密消息
解密算法:
解密规则:
    - 输入:
        - 密文: 大写字母字符串
    - 输出:
        - 明文: 大写字母字符串
    - 准备:
        - 仿射字母表 = "XMJQUDONPRGTVBWFAKSHZCYEIL"
        - 将每个字母与其在仿射字母表中的位置关联（从0开始）:
            X->0, M->1, J->2, Q->3, U->4, D->5, O->6, N->7,
            P->8, R->9, G->10, T->11, V->12, B->13, W->14, F->15,
            A->16, K->17, S->18, H->19, Z->20, C->21, Y->22, E->23, I->24, L->25
        - A: 3
        - B: 5
        - A_inv: 9
    - 解密步骤:
        - 对于每个密文字符c:
            - 设y为其在仿射字母表中的位置
            - 计算x:
                - x = A_inv * (y - B) % n
            - 用仿射字母表中位置x处的字母替换c，形成解密消息

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - affine alphabet = "XMJQUDONPRGTVBWFAKSHZCYEIL"
    - Associate each letter with its position in the affine alphabet (starting from 0):

        X -> 0, M -> 1, J -> 2, Q -> 3, U -> 4, D -> 5, O -> 6, N -> 7,
        P -> 8, R -> 9, G -> 10, T -> 11, V -> 12, B -> 13, W -> 14, F -> 15,
        A -> 16, K -> 17, S -> 18, H -> 19, Z -> 20, C -> 21, Y -> 22, E -> 23, I -> 24, L -> 25

    - A: 3
    - B: 5
    - A_inv: 9
- Encryption Steps:
    - For each given plaintext character p:
        - Let  x  denote its position in the affine alphabet.
        - Apply the affine coding function to compute y:
            - y = (Ax + B) mod 26
        - Find the corresponding letter in the affine alphabet at position  y , forming the encrypted message.

 **Decryption Rules:**

- Input:
    - Ciphertext: Uppercase letters string.
- Output:
    - Plaintext: Uppercase letters string.
- Preparation:
    - affine alphabet = "XMJQUDONPRGTVBWFAKSHZCYEIL"
    - Associate each letter with its position in the affine alphabet (starting from 0):

        X -> 0, M -> 1, J -> 2, Q -> 3, U -> 4, D -> 5, O -> 6, N -> 7,
        P -> 8, R -> 9, G -> 10, T -> 11, V -> 12, B -> 13, W -> 14, F -> 15,
        A -> 16, K -> 17, S -> 18, H -> 19, Z -> 20, C -> 21, Y -> 22, E -> 23, I -> 24, L -> 25

    - A: 3
    - B: 5
    - A_inv: 9
- Decryption Steps (exact opposite of encryption steps):
    - For each given ciphertext character c:
        - Let y denote its position in the affine alphabet.
        - Calculate x:
            - x = A_inv * (y - B) % n.
        - Replace c with the letter at position x  in the affine alphabet to form the decrypted message.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
- 输入:
    - 明文: 仅包含大写字母的字符串，不含标点和空格
- 输出:
    - 密文: 大写字母字符串
- 准备:
    - 标准字母表: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    - 反转字母表: "ZYXWVUTSRQPONMLKJIHGFEDCBA"
    - 替换字母表: "RFDJUHABCEGIKLMNOPQSTVWXYZ"
- 加密步骤:
    - 对明文中的每个字母p:
    - (1) 使用反转字母表进行反向映射。在标准字母表中找到其位置，并用反转字母表中对应位置的字母替换。例如，A映射为Z，B映射为Y。
    - (2) 将步骤(1)得到的字母在标准字母表顺序中向前移动4位。例如，如果p=A，经过步骤(1)映射为Z，然后Z在标准字母表中向前移动4位得到D。
    - (3) 将步骤(2)得到的字母，在标准字母表中找到其位置，用替换字母表中对应位置的字母替换，得到最终的密文字母。例如，如果经过步骤(2)得到字母D，则映射为J。
解密算法:
解密规则:
- 输入:
    - 密文: 大写字母字符串
- 输出:
    - 明文: 大写字母字符串
- 准备:
    - 标准字母表: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    - 反转字母表: "ZYXWVUTSRQPONMLKJIHGFEDCBA"
    - 替换字母表: "RFDJUHABCEGIKLMNOPQSTVWXYZ"
- 解密步骤(与加密步骤完全相反):
    - (1) 对密文中的每个字母c，在替换字母表中找到其位置，用标准字母表中对应位置的字母替换。
    - (2) 将步骤(1)得到的字母按标准字母表顺序向后移动4位。
    - (3) 将步骤(2)得到的字母，在反转字母表中找到其位置，然后用标准字母表中对应位置的字母替换。例如，Z映射为A，Y映射为B。

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - standard_alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    - reversed_alphabet: "ZYXWVUTSRQPONMLKJIHGFEDCBA"
    - substitution_alphabet: "RFDJUHABCEGIKLMNOPQSTVWXYZ"
- Encryption Steps:
    - For each letter p in the given Plaintext:
    - (1) Use reversed_alphabet for reverse mapping. Find its position in the standard_alphabet and replace it with the letter in the corresponding position in reversed_alphabet. For example, A is mapped to Z and B is mapped to Y.
    - (2) Move the letter obtained in (1) forward 4 places in the standard_alphabet order. For example, if p=A, after (1) is mapped to Z, then Z is shifted forward 4 positions in the standard_alphabet to get D.
    - (3) Replace the letter obtained from (2) by finding its position in standard_alphabet and using the corresponding letter in substitution_alphabet, resulting in the final ciphertext letter. For example, if the letter obtained by going through (2) is D, it is mapped as J.

**Decryption Rules:**

- Input:
    - Ciphertext: Uppercase letters string.
- Output:
    - Plaintext: Uppercase letters string.
- Preparation:
    - alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    - reversed_alphabet: "ZYXWVUTSRQPONMLKJIHGFEDCBA"
    - substitution_alphabet: "RFDJUHABCEGIKLMNOPQSTVWXYZ"
- Decryption Steps (exact opposite of encryption steps):
    - (1) For each letter c in Ciphertext, find its position in substitution_alphabet and replace it with the corresponding letter in standard_alphabet.
    - (2) Shift the letter obtained from (1) backward by 4 positions according to the standard_alphabet order.
    - (3) Replace the letter obtained from (2) by finding its position in reversed_alphabet, then replace it with the corresponding letter in standard_alphabet. For example, Z maps to A, Y maps to B.


请根据加密算法对明文进行加密
加密规则:
- 输入:
    - 明文: 大写字母字符串，不含标点和空格
- 输出:
    - 密文: 数字字符串，不含标点和空格
- 准备:
    - 3个网格(所有行列号从0开始计数):
        - 网格1 (3x9):
            Q W E R T Y U I O
            P A S D F G H J K
            L Z X C V B N M #
        - 网格2 (9x3):
            Q W E
            R T Y
            U I O
            P A S
            D F G
            H J K
            L Z X
            C V B
            N M #
        - 网格3 (3x3):
            1 2 3
            4 5 6
            7 8 9
- 加密步骤:
    - 移除所有空格和标点，将文本转换为大写字母
    - 将明文切分为6个字符一组，如果最后一组不足6个字符，用#填充
    - 将每组6个字符分成3个二元组
    - 对每个二元组(L1, L2)执行以下操作:
        - 确定L1在网格1中的行列号(l1_row, l1_col)
        - 确定L2在网格2中的行列号(l2_row, l2_col)
        - 在网格3中用l1_row和l2_col找到对应数字num3
        - 输出三元组(l1_col, num3, l2_row)
    - 将所有三元组连接成一个数字串作为加密信息

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: A numeric string without punctuation and spaces.
- Preparation:
    - 3 Girds(All row and column numbers are counted from 0.):
        - Grid 1 (3x9):

            Q W E R T Y U I O
            P A S D F G H J K
            L Z X C V B N M #

        - Grid 2 (9x3):

            Q W E
            R T Y
            U I O
            P A S
            D F G
            H J K
            L Z X
            C V B
            N M #

        - Grid 3 (3x3):

            1 2 3
            4 5 6
            7 8 9

- Encryption Steps:
    - Remove all spaces and punctuation from the plain text and convert them to capital letters.
    - Cut the plaintext into groups of 6 characters, and if a group is less than 6 characters long, fill it with `#`.
    - Split each group of 6 characters into 3 binary groups.
    - For each binary group `(L1, L2)` do the following:
        - Determine the row and column numbers  of `L1` in `grid1` as `(l1_row, l1_col)`.
        - Determine the row and column numbers of `L2` in `grid2` as `(l2_row, l2_col)`.
        - Find the corresponding number `num3` in `grid3` from `l1_row` and `l2_col`.
        - Output the triple `(l1_col, num3, l2_row)` of the three numbers.
            - For example, for the binary (T,H), the row and column numbers of T in `grid1` are (0,4), the row and column numbers of H in `grid2` are (5,0).
            - Based on `l1_row` (0) and `l2_col`(0) , the corresponding number `num3` found in `grid3` is 1, and the final ternary is (4, 1, 5).
    - After performing the previous step multiple times and converting all the binary groups to triples, read them in turn to form a string of numbers that can be used as encrypted information. For example (4, 1, 5), (2, 3, 3), (8, 1, 8), the final encrypted message is 415233818.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
    - 输入:
        - 明文: 大写字母字符串,不含标点和空格
    - 输出:
        - 密文: 大写字母字符串
    - 准备:
        - LETTERS = ['J', 'D', 'W', 'O', 'T', 'R', 'A', 'C', 'X', 'Q', 'M', 'F', 'Y', 'E', 'Z', 'G', 'U', 'K', 'P', 'V', 'B', 'S', 'H', 'N', 'L', 'I']
        - 将每个字母与其在LETTERS中的位置关联(从0开始):
            J->0, D->1, W->2, O->3, T->4, R->5, A->6, C->7, X->8, Q->9, M->10, F->11, Y->12, E->13, Z->14, G->15, U->16, K->17, P->18, V->19, B->20, S->21, H->22, N->23, L->24, I->25
        - 初始卡牌序列:
            - 54张卡牌的列表,包括52张花色牌和2张可区分的王牌(A王牌和B王牌)。花色牌按四种花色顺序编号1-52,王牌值为53和54。
            - [9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 53, 26, 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 54, 46, 23, 31, 24, 14, 8, 33, 2, 49, 45, 21]
        - 密钥流算法:
            该算法通过移动卡牌生成密钥流值。算法是确定性的,意味着密钥流值仅取决于卡牌的初始顺序。卡牌组被视为循环数组,允许需要移到底部的卡牌绕到顶部。

            执行以下步骤生成密钥流的一个字符:
            1. 找到A王牌并下移一位。如果是最后一张牌,则成为第二张牌。不能成为第一张牌。
            2. 找到B王牌并下移两位。如果是倒数第二张牌,则绕到第二位。如果是最后一张牌,则成为第三张牌。不能成为第一张牌。
            3. 进行"三切":用王牌作为边界将牌组分成三部分,然后交换顶部和底部。王牌本身及其之间的牌保持不变。
            4. 进行"计数切":检查牌组底牌。如果是王牌(53/54),其值固定为53。从牌组顶部取出该数量的牌,插入到最后一张牌的上方。
            5. 查看顶牌的值。同样,任何王牌计为53。计算该牌下方的位置数,使用该位置的牌值作为下一个密钥流值。如果计算出的牌是王牌,忽略它并重复密钥流算法。
            6. 返回生成的密钥流值
    - 加密步骤:
        - cards=初始卡牌序列
        - 对每个明文字符p:
            - 使用字母表将p转换为对应的位置值x(从0开始)
            - 使用初始卡牌序列为p生成密钥流值y:
                - y, cards = 密钥流算法(cards)
                - 该算法修改卡牌顺序,下次执行使用新顺序
            - 当密钥流值y加到位置值x时,应用模26运算得到z:
                - z=(y+x) % 26
            - 使用LETTERS列表返回对应位置z的字母
            - 将其附加到密文
解密算法:
解密规则:
    - 输入:
        - 密文: 大写字母字符串
    - 输出:
        - 明文: 大写字母字符串
    - 准备:
        - LETTERS = ['J', 'D', 'W', 'O', 'T', 'R', 'A', 'C', 'X', 'Q', 'M', 'F', 'Y', 'E', 'Z', 'G', 'U', 'K', 'P', 'V', 'B', 'S', 'H', 'N', 'L', 'I']
        - 将每个字母与其在LETTERS中的位置关联(从0开始):
            J->0, D->1, W->2, O->3, T->4, R->5, A->6, C->7, X->8, Q->9, M->10, F->11, Y->12, E->13, Z->14, G->15, U->16, K->17, P->18, V->19, B->20, S->21, H->22, N->23, L->24, I->25
        - 初始卡牌序列(与加密相同)
        - 密钥流算法(与加密相同)
    - 解密步骤(与加密步骤完全相反):
        - cards=初始卡牌序列
        - 对每个密文字符c:
            - 使用LETTERS将c转换为对应的位置值z(从0开始)
            - 为c生成密钥流值y:
                - y, cards = 密钥流算法(cards)
                - 该算法修改卡牌顺序,下次执行使用新顺序
            - 从密文字符c计算原始位置值x:
                - x=(z-y) mod 26
            - 使用LETTERS列表返回对应位置x的字母
            - 将其附加到解密明文

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext: Uppercase letters string.
- Preparation:
    - LETTERS = ['J', 'D', 'W', 'O', 'T', 'R', 'A', 'C', 'X', 'Q', 'M', 'F', 'Y',
    'E', 'Z', 'G', 'U', 'K', 'P', 'V', 'B', 'S', 'H', 'N', 'L', 'I']
    - Associate each letter with its position in the LETTERS (starting from 0):

        J -> 0, D -> 1, W -> 2, O -> 3, T -> 4, R -> 5, A -> 6, C -> 7, X -> 8, Q -> 9,
        M -> 10, F -> 11, Y -> 12, E -> 13, Z -> 14, G -> 15, U -> 16, K -> 17, P -> 18,
        V -> 19, B -> 20, S -> 21, H -> 22, N -> 23, L -> 24, I -> 25

    - Initial sequence of cards:
        - A list of 54 numbers, including a randomly shuffled deck consisting of 52 suited cards and two distinguishable jokers known as the A Joker and B Joker. Suited cards are valued sequentially across four suits: Clubs, Diamonds, Hearts, and Spades, with values ranging from 1 to 52, while the jokers are valued 53 and 54.
        - [9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 53, 26, 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 54, 46, 23, 31, 24, 14, 8, 33, 2, 49, 45, 21]
    - **Keystream Algorithm**

        This algorithm generates keystream values by moving cards within a deck. The keystream algorithm is *deterministic*, meaning keystream values depend solely on the initial order of the deck. The deck is treated as a circular array, allowing a card that needs to move below the bottom card to wrap around to the top (in other words, the first card follows the last card).

        For example, starting with:
        9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 53, 26, 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 54, 46, 23, 31, 24, 14, 8, 33, 2, 49, 45, 21

        Perform the following steps to generate a character of the keystream:

        1. Locate card A and move it down by one position. If it's the last card, it becomes the second card. It cannot become the first card. The deck now looks like this:
        9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 26, **53,** 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 54, 46, 23, 31, 24, 14, 8, 33, 2, 49, 45, 21
        2. Locate card B and move it down by two positions. Note, if it's the second last card, it will wrap around to become the second card. If it's the last card, it will become the third card. It cannot become the first card. The deck now looks like this:
        9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 26, **53,** 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 46, 23, **54,** 31, 24, 14, 8, 33, 2, 49, 45, 21
        3. Perform a "triple cut": Divide the deck into three parts, using the jokers as boundaries, then swap the top and bottom parts. The jokers themselves and the cards between them remain unchanged.
        31, 24, 14, 8, 33, 2, 49, 45, 21, **53,** 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 46, 23, **54,** 9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, 26
        4. Perform a "count cut": Examine the bottom card of the deck. If it's a joker (53/54), its value remains fixed at 53. Take out that many cards from the top of the deck and insert them just above the last card of the deck.
        29, 20, 51, 6, 7, 52, 34, 35, 5, 50, 9, 46, 23, **54,** 9, 25, 44, 38, 40, 22, 11, 36, 13, 39, 18, 42, 10, **31, 24, 14, 8, 33, 2, 49, 45, 21,** 53, 12, 1, 16, 3, 43, 37, 17, 30, 4, 28, 48, 27, 41, 32, 15, 47, 26
        5. Now, look at the value of the top card. Similarly, any joker counts as 53. Calculate the number of positions below this card, and use that card's value as the next value in the keystream. If the calculated card is a joker, ignore it and repeat the keystream algorithm. In this example, the top card is 29, so the value of the 30th card (i.e., 14) determines the keystream value. (Note that no cards change position in this step; this step only determines the keystream value).
        6. Return the resulting keystream value: 14
- Encryption Steps:
    - cards=Initial sequence of cards
    - For each given plaintext character p:
        - Use the alphabet to convert p to the corresponding positional value x. (starting from 0).
        - Generate a keystream value y for p using the Initial sequence of cards:
            - y, cards = Keystream Algorithm (cards)
            - This algorithm modifies the order of the pile of cards, and the next execution then uses the new order.
        - When the keystream value y is added to the position value x, the mod 26 operation is applied to obtain z:
            - z=(y+x) % 26
        - Use the LETTERS list to return the letter corresponding to position z.
        - Append it to the ciphertext.

 **Decryption Rules:**

- Input:
    - Ciphertext: Uppercase letters string.
- Output:
    - Plaintext: Uppercase letters string.
- Preparation:
    - LETTERS = ['J', 'D', 'W', 'O', 'T', 'R', 'A', 'C', 'X', 'Q', 'M', 'F', 'Y',
    'E', 'Z', 'G', 'U', 'K', 'P', 'V', 'B', 'S', 'H', 'N', 'L', 'I']
    - Associate each letter with its position in the LETTERS (starting from 0):

        J -> 0, D -> 1, W -> 2, O -> 3, T -> 4, R -> 5, A -> 6, C -> 7, X -> 8, Q -> 9,
        M -> 10, F -> 11, Y -> 12, E -> 13, Z -> 14, G -> 15, U -> 16, K -> 17, P -> 18,
        V -> 19, B -> 20, S -> 21, H -> 22, N -> 23, L -> 24, I -> 25

    - Initial sequence of cards(Same as encryption)
    - Keystream Algorithm(Same as encryption)
- Decryption Steps (exact opposite of encryption steps):
    - cards=Initial sequence of cards
    - For each ciphertext character c:
        - Convert c to its corresponding positional value z using the LETTERS (starting from 0).
        - Generate the keystream value y for c:
            - y, cards = Keystream Algorithm (cards)
            - This algorithm modifies the order of the pile of cards, and the next execution then uses the new order.
        - Calculate the original positional value x from ciphertext character c:
            - x=(z-y) mod 26
        - Use the LETTERS list to return the letter corresponding to position x.
        - Append it to the decrypted plaintext.


请根据加密算法和解密算法对密码进行解密
加密算法:
加密规则:
- 输入:
    - 明文: 大写字母字符串，不含标点和空格
- 输出:
    - 密文: 不含标点和空格的字符串
- 准备:
    - 每行最大字符数: 5
- 加密步骤:
    - 行数从1开始计数
    - 明文按特殊方式排列：奇数行从左到右写，偶数行从右到左写，每行最多五个字母
        - 例如，对于明文"LIDAHELLOWORLD"，先从左到右写第一行为LIDAH，然后从右到左写第二行为WOLLE，然后从左到右写第三行为ORLD，写完的全部内容表示如下
        LIDAH
        WOLLE
        ORLD
    - 然后按列读取，每列从上到下读取，每读完一列加一个"#"，读出的内容即为最终密文
        - 例如，上述写好的内容按列读取为LWO#IOR#DLL#ALD#HE#
解密算法:
解密规则:
- 输入:
    - 密文: 不含标点和空格的字符串
- 输出:
    - 明文: 大写字母字符串，不含标点和空格
- 准备:
    - 行数: 5
- 解密步骤(与加密步骤完全相反):
    - 对密文中的每个字符，从上到下写入；如果遇到#，则切换到下一列继续写入，直到整个密文写完
        - 例如，对于密文LWO#IOR#DLL#ALD#HE#，写出如下
        LIDAH
        WOLLE
        ORLD
    - 然后按照奇数行从左到右读，偶数行从右到左读的顺序依次读取，最终结果即为解密后的明文
        - 例如，对于上述写好的内容，第一行从左到右读为LIDAH，第二行从右到左读为ELLOW，第三行从左到右读为ORLD，最终全部内容连接起来，解密明文为LIDAHELLOWORLD

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  A string without punctuation and spaces.
- Preparation:
    - Maximum number of characters per line: 5
- Encryption Steps:
    - Lines are counted from 1.
    - The plaintext is arranged in a special way: an odd number of lines are written from left to right, and an even number of lines are written from right to left, with a maximum of five letters per line.
        - For example, for the plaintext "LIDAHELLOWORLD", first write the first line, from left to right as LIDAH, and then write the second line, from right to left as WOLLE, and then write the third line, from left to right as ORLD, the entire content of the finished writing is expressed as follows
        LIDAH
        WOLLE
        ORLD
    - Then read by column, each column is read from the top down, each read a column plus a "#", read out the contents of the final ciphertext.
        - For example, the above written content is read as LWO#IOR#DLL#ALD#HE# by column.

 **Decryption Rules:**

- Input:
    - Ciphertext: A string without punctuation and spaces.
- Output:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Preparation:
    - Number of lines: 5
- Decryption Steps (exact opposite of encryption steps):
    - For each character in the ciphertext, it is written from top to bottom; if it encounters #, it switches to the next column and continues writing until the entire ciphertext has been written.
        - For example, for the ciphertext LWO#IOR#DLL#ALD#HE#,it is written as
        LIDAH
        WOLLE
        ORLD
    - Then according to the odd-numbered rows from left to right read, the even number of rows from right to left read the order of sequential reading, the final result is the decrypted plaintext.
        - For example, for the above written content, the first line, read from left to right as LIDAH, the second line, read from right to left as ELLOW, the third line, read from left to right as ORLD, and ultimately the entire content connected, decrypted plaintext as LIDAHELLOWORLD.


请根据加密算法对明文进行加密
加密规则:
    - 输入:
        - 明文: 大写字母和空格组成的字符串
    - 输出:
        - 密文: 表示加密数据的十六进制字符串(其中A-E需要大写)
    - 准备:
        - 固定密钥
            - KEY = b'1234567890ABCDEF'
        - S盒
            - S_BOX = {
            0x00: 0x0F, 0x01: 0x0A, 0x02: 0x07, 0x03: 0x05,
            0x04: 0x09, 0x05: 0x03, 0x06: 0x0D, 0x07: 0x00,
            0x08: 0x0E, 0x09: 0x08, 0x0A: 0x04, 0x0B: 0x06,
            0x0C: 0x01, 0x0D: 0x02, 0x0E: 0x0B, 0x0F: 0x0C
            }
    - 加密步骤:
        1. 填充: 如果明文长度不是8字节的倍数，用\x00(空字符)填充使其长度成为8字节的倍数
        2. 分块: 将填充后的明文分成8字节的块
        3. 块加密:
            - 转换为字节: 使用ASCII编码将每个块转换为字节
            - 与密钥XOR: 字节块与固定密钥进行XOR运算
            - 替换: 使用S盒替换每个字节的高4位和低4位并拼接
            - 置换: 通过将每个字节左移1位进行简单置换
            - 与密钥XOR: 置换后的字节块再次与固定密钥进行XOR运算
        4. 十六进制编码: 将加密后的字节块转换为十六进制字符串
        5. 拼接: 将所有加密块的十六进制字符串拼接形成最终密文

**Encryption Rules:**

- Input:
    - Plaintext: A string of uppercase letters and spaces.
- Output:
    - Ciphertext: A hexadecimal string representing the encrypted data (where A-E needs to be capitalised).
- Preparation:
    - Fixed key
        - KEY = b'1234567890ABCDEF'
    - S_BOX
        - S_BOX = {
        0x00: 0x0F, 0x01: 0x0A, 0x02: 0x07, 0x03: 0x05,
        0x04: 0x09, 0x05: 0x03, 0x06: 0x0D, 0x07: 0x00,
        0x08: 0x0E, 0x09: 0x08, 0x0A: 0x04, 0x0B: 0x06,
        0x0C: 0x01, 0x0D: 0x02, 0x0E: 0x0B, 0x0F: 0x0C
        }
- Encryption Steps:
    1. Padding: If the plaintext is not a multiple of 8 bytes, pad it with \x00 (null character) to make its length a multiple of 8 bytes.
    2. Block Splitting: Divide the padded plaintext into 8-byte blocks.
    3. Block Encryption:
        - Convert Block to Bytes: Convert each block to bytes using ASCII encoding.
        - XOR with Key: Apply XOR between the byte block and the fixed key.
        - Substitute:  Use the S_BOX Replacement Box to replace the high 4 bits and low 4 bits in each byte before stitching them together.
        - Permute: Perform a simple permutation by rotating each byte left by 1 bit.
        - XOR with Key: Apply XOR between the permuted byte block and the fixed key again.
    4. Hexadecimal Encoding: Convert the encrypted byte blocks to a hexadecimal string.
    5. Concatenate: Concatenate all the hexadecimal strings of the encrypted blocks to form the final ciphertext.


请根据加密算法和解密算法对密码进行解密
加密算法:

加密规则:
- 输入:
    - 明文: 仅包含大写字母的字符串，不含标点和空格
- 输出:
    - 密文: 由逗号分隔的数字序列，例如"y1,y2,..."
- 准备:
    - e: 263
    - n: 299
- 加密步骤:
    - 对明文中的每个字母p:
        - 获取字母p对应的ASCII码的十进制数x
        - 计算x^e mod n作为该字母的密文数字y，这里^表示乘法运算
    - 最后，将所有y用逗号连接形成最终密文

解密算法:

解密规则:
- 输入:
    - 密文: 由逗号分隔的数字序列，例如"y1,y2,..."
- 输出:
    - 明文: 仅包含大写字母的字符串，不含标点和空格
- 准备:
    - e: 263
    - n: 299
- 解密步骤:
    - 对密文中的每个数字c:
        - 计算z = c^e mod n，这里^表示乘法运算
        - 根据z的十进制值，使用ASCII码找到对应的字母作为明文字母p
    - 最后，将所有p连接得到最终明文

**Encryption Rules:**

- Input:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Output:
    - Ciphertext:  A sequence of numbers separated by ,. For example, "y1,y2,…".
- Preparation:
    - e: 263
    - n: 299
- Encryption Steps:
    - For each letter p in the plaintext:
        - Get the decimal number x of the value corresponding to the ascii code of p.
        - Compute x^e mod n as the ciphertext number y for that letter p . Here ^ denotes the multiplication operation.
    - Finally, concatenate all the y's and separate them with commas for the final ciphertext.

 **Decryption Rules:**

- Input:
    - Ciphertext: A sequence of numbers separated by ,. For example, "y1,y2,…".
- Output:
    - Plaintext: Uppercase letters string without punctuation and spaces.
- Preparation:
    - e: 263
    - n: 299
- Decryption Steps:
    - For each number c in the ciphertext:
        - Calculate z = c^e mod n. Here ^ means multiplication.
        Based on the decimal number represented by z, use the ascii code to find the corresponding letter as the plaintext letter p.
    - Finally, concatenate all p's to get the final plaintext.