#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <stdio.h>

using namespace std;

typedef unsigned short ushort;
typedef char byte;

// delete s[i] symbol
void erase(char s[], int i)
{
    int sizeEl = sizeof(char);
    __asm
    {
        mov eax, i              // eax = i
        add eax, 1              // eax = i + 1
        imul eax, sizeEl        // eax = (i + 1)*sizeEl
        add eax, s              // eax = (i + 1)*sizeEl + s

        L:
            mov edx, eax        // edx = (i + 1)*sizeEl + s
            sub edx, sizeEl     // edx = i*sizeEl + s

            mov bl, [eax]       // ebx = s[i + 1]
            mov [edx], bl       // s[i] = s[i + 1]
            cmp bl, '\0'        // s[i + 1] != '\n' ? L : exit
            je END

            add eax, sizeEl     // eax = next s[i + 1]
            jmp L

        END:
    }
}

// if(x < 2) y = 2 - x
// else y = a + 3
int function(int x, int a)
{
    int y;
    __asm {
        mov eax, x
        cmp eax, 2
        jge B
        A : mov eax, 2 // x < 2  y = 2 - x
            sub eax, x
            mov y, eax
            jmp END

        B : mov eax, a // x >= 2  y = a + 3
            add eax, 3
            mov y, eax

        END:
    }
    return y;
}

// output binary number
template<typename T>
void binaryOut(T n, int b1, int b2)
{
    int start = sizeof(T) * 8 - 1;
    if (b1 == -1) b1 = start + 1;
    else b1--;

    if (b2 == -1) b2 = start + 1;
    else b2--;

    for (int i = start; i >= 0; i--)
    {
        if (i == b1 || i == b2)
        {
            cout << '[' << ((n & (1 << i)) >> i) << ']';
        }
        else cout << ((n & (1 << i)) >> i);
    }

    cout << endl;
}

// swap 3 and 5 bits of number
void bitSwap(int* val)
{
    // val += (3b - 5b) * 12
    // swap(3b, 5b)
    cout << "Default\n";
    binaryOut(*val, 3, 5);

    __asm
    {
        mov ebx, val        // ebx = addr val

        mov eax, [ebx]      // eax = [val]
        and eax, 16         // eax = 5 bit
        shr eax, 4          //
        mov edx, eax        // edx = 5 bit

        mov eax, [ebx]      // eax = [val]
        and eax, 4          // eax = 3 bit
        shr eax, 2          //

        sub eax, edx        // eax = 3bit - 5bit
        mov edx, 12         // edx = 12

        imul edx            // eax = (3bit - 5bit) * 12
        add eax, [ebx]      // eax = eax + [val]
        mov [ebx], eax      // val = eax
    }
    cout << "Swap(3b, 5b)\n";
    binaryOut(*val, 3, 5);

    // val *= 8
    __asm
    {
        mov ebx, val        // ebx = addr val

        mov eax, [ebx]      // eax = [val]
        shl eax, 3          // eax = val * 8
        mov [ebx], eax      // val = eax
    }
    cout << "Val * 8\n";
    binaryOut(*val, -1, -1);

    // NOT val
    __asm
    {
        mov ebx, val        // ebx = addr val

        mov eax, [ebx]      // eax = [val]
        not eax             // not eax
        mov [ebx], eax      // val = eax
    }
    cout << "NOT val\n";
    binaryOut(*val, -1, -1);
}

// y = (5 + 9) / 3 - 16*3/(2 + 3) + (23/3)/3 - 2
// notation 5 9 + 3 / 16 3 * 2 3 + / - 23 3 / 3 / + 2 -
int expression()
{
    int y = 0;

    __asm
    {

    }

    return y;
}

// copy from Array.a to Array.b
void copyArr(int* a, int* b, int n)
{
    int sizeEl;
    int space;
    __asm
    {
        mov sizeEl, type a // размер элемента

        mov eax, b          // eax = b
        sub eax, a          // eax = b - a
        mov space, eax      // смещение

        mov eax, n          // eax = n
        dec eax             // eax = n - 1
        mov ecx, eax        // ecx = n - 1

        mov ebx, a          // база

        // b[i] = <база> + <множитель> * <индекс> + <смещение>
        // b[i] = a[ebx + sizeEl*ecx + space]

        L :
            mov eax, ecx    // eax = ecx
            mul sizeEl      // eax = ecx * sizeEl
            add eax, ebx    // eax = ebx +
            mov edx, [eax]  // edx = a[ecx]

            add eax, space  // memory of b[i] = ebx + sizeEl*ecx + space
            mov [eax], edx  // b[ecx] = a[ecx]

            dec ecx         // ecx --
        cmp ecx, 0          // ecx >= 0 ? L : exit
        JGE L
    }
}

int main()
{
    int n;
    cin >> n;
    int* a = new int[n];
    int* b = new int[n];
    for (int i = 0; i < n; i++)
        cin >> a[i];

    copyArr(a, b, n);

    for (int i = 0; i < n; i++)
        cout << b[i] << ' ';

    cout << expression() << endl;

    int val;
    cin >> val;
    bitSwap(&val);

    int x, aVal;
    cin >> x >> aVal;
    cout << function(x, aVal) << endl;

    int i;
    char s[256];
    scanf("%255[^\n]", s);
    scanf("%d", &i);
    erase(s, i);
    printf("%s", s);

    return 0;
}