local function print(...)
    local szText = Input.GetText("Input1");
    for i, v in pairs{...}do
        szText = szText .. tostring(v).."\t";
    end

    Input.SetText("Input1", szText.."\r\n");
end;

if(not ASM.Initialize())then
    error("Assembler couldn't be initialized.");
end

-- Calculate some stuff using your input!
local function asm_test_1()
    local hAssembly = ASM.Assemble[[
        USE32                       ;-- Important, use 32 bits. Don't use USE16 and USE64, this is a 32 bit application!
        ORG     100h                ;-- The base

        XOR     EAX, EAX
        MOV     EAX, [ESP + 4]      ;-- Place argument 1 in EAX for operation! Arguments to a function call are placed in ESP normally.
        SAL     EAX, 2              ;-- Shift it left 2 bits.
        SUB     EAX, 100            ;-- Subtract 100.
        SAR     EAX, 1              ;-- Shift it right 1 bit.

        RETN                        ;-- return, the value in EAX is usually returned to the calling process.
    ]];

    if(hAssembly.assembled)then
        local result = hAssembly(120); -- Call the above block of assembly with the argument 120 in ESP
        print(result);
    else
        local asmError = hAssembly:GetError();
        if(asmError)then
            if(asmError.errorCode ~= 0)then -- If it wasn't successful and errorCode is 0, then you probably tried assembling an empty block.
                Dialog.Message("Assembler error: "..tostring(asmError.errorCode), "Line "..tostring(asmError.errorLine)..": "..asmError.errorMessage.."\r\nCode at line: "..asmError.errorLineString);
            end
        end
    end

    hAssembly:Free();
end

-- Call MessageBox A and proxy the arguments through assembly!
local function asm_test_2()
    local user32 = Library.Load("user32.dll");
    if(not user32)then return;end;
    local MessageBoxA = user32:GetProcAddress_("MessageBoxA");
    if(not MessageBoxA)then return;end;

    local hAssembly = ASM.Assemble([[
        USE32                           ;-- Important, use 32 bits. Don't use USE16 and USE64, this is a 32 bit application!
        ORG     100h                    ;-- The base

        PUSH    EBP                     ;-- Push EBP on the stack
        MOV     EBP, ESP                ;-- Move the arguments in ESP to EBP

        PUSH    DWORD [EBP + 20]        ;-- EBP contains the arguments, last argument at offset 20, first argument at offset 8.
        PUSH    DWORD [EBP + 16]        ;-- PUSH pushes these values onto the stack for CALL to pass onto the called code
        PUSH    DWORD [EBP + 12]        ;-- Push the last argument first!
        PUSH    DWORD [EBP + 08]        ;-- So, the first PUSH rule pushes the flags (68), 2nd pushes message, 3rd pushes title, 4th pushes window handle

        XOR     EAX, EAX                ;-- Reset the EAX register to 0

        ;-- Move the pointer to MessageBoxA into EAX, so we can call that function
        ;MOV        EAX, DWORD ]]..tostring(MessageBoxA)..[[ ;-- If you use this form of concatenation, use a space after the opening operator! If you do not, newlines are ignored.
        MOV     EAX, DWORD [EBP + 24]   ;-- Instead of concatenating the ASM, you can also provide this function with a pointer to MessageBoxA
        CALL    EAX                     ;-- Call the function address stored in EAX
        POP     EBP                     ;-- POP (remove) EBP from the stack, restoring the stack and allowing EAX to get returned.

        RETN
    ]]);

    if(hAssembly.assembled)then
        -- The 68 as argument 4 below is Bitwise.Or(MB_ICONINFORMATION, MB_YESNO)
        local result = hAssembly(Application.GetWndHandle(), "Hello World!", "Title", 68, MessageBoxA); -- Call the above block of assembly.
        if(result == IDYES)then
            print("You clicked yes! :D");
        else
            print("You clicked no! :(");
        end
    else
        local asmError = hAssembly:GetError();
        if(asmError)then
            if(asmError.errorCode ~= 0)then -- If it wasn't successful and errorCode is 0, then you probably tried assembling an empty block.
                Dialog.Message("Assembler error: "..tostring(asmError.errorCode), "Line "..tostring(asmError.errorLine)..": "..asmError.errorMessage.."\r\nCode at line: "..asmError.errorLineString);
            end
        end
    end

    hAssembly:Free();
end

-- Calculate a CRC32 checksum on data you provide!
local function CRC32(szString, initCRC)
    local CRC       = 0;
    if(type(initCRC) == "number")then
        CRC = initCRC;
    end
    local hAssembly = ASM.Assemble[[
        USE32
        ORG         100h

        PUSH        EBP                   ;-- Push EBP on the stack so it'll hold our arguments.
        MOV         EBP, ESP              ;-- Move ESP into EBP, we use EBP to get to our arguments.

        ;-- Read all the arguments again and place them in registers.
        MOV         EDI, DWORD [EBP + 12] ;-- length
        MOV         ESI, DWORD [EBP + 08] ;-- pointer, the function call methods in MemoryEx obtain a pointer to the strings you provide :)
        MOV         ECX, DWORD [EBP + 16] ;-- init crc32
        NOT         ECX                   ;-- to mimic the behaviour of PB's CRC32Fingerprint function, we have to NOT the init crc. Usually the init crc is -1, PB works with 0. NOT 0 = -1 (0xFFFFFFFF)
        MOV         EDX, -1               ;-- EDX = -1

        nextbyte:                         ;-- A label that gets the next byte from the buffer.
            XOR     EAX, EAX              ;-- EAX = 0
            XOR     EBX, EBX              ;-- EBX = 0
            DB      0xAC                  ;-- LODSB instruction to get the next byte
            XOR     AL, CL                ;-- XOR AL with CL
            MOV     CL, CH                ;-- CL = CH
            MOV     CH, DL                ;-- CH = DL
            MOV     DL, DH                ;-- DL = DH
            MOV     DH, 8                 ;-- DH = 8

        nextbit:                          ;-- A label that gets the next bit from the byte.
            SHR     BX, 1                 ;-- Shift the bits in BX right by 1 bit.
            RCR     AX, 1                 ;-- (rotate through carry) Rotate bits in AX by 1
            JNC     nocarry               ;-- Jump to nocarry if carry flag wasn't set
            XOR     AX, 0x08320           ;-- XOR AX with 33568
            XOR     BX, 0x0EDB8           ;-- XOR BX with 60856

        nocarry:                          ;-- If the carry flag wasn't set
            DEC     DH                    ;-- DH = DH - 1
            JNZ     nextbit               ;-- If DH isn't zero, jump to nextbit
            XOR     ECX, EAX              ;-- XOR ECX with EAX
            XOR     EDX, EBX              ;-- XOR EDX with EBX
            DEC     EDI                   ;-- EDI = EDI - 1, finished a byte.
            JNZ     nextbyte              ;-- If EDI isn't zero, jump to nextbyte
            NOT     EDX                   ;-- Invert EDX bits - 1s complement
            NOT     ECX                   ;-- Invert ECX bits - 1s complement
            MOV     EAX, EDX              ;-- Move EDX into EAX
            ROL     EAX, 16               ;-- Rotate bits in EAX left by 16 places
            MOV     AX, CX                ;-- Move CX into AX

        POP     EBP                       ;-- Remove EBP from the stack, which held the arguments.
        RETN                              ;-- Return, the value in EAX contains the CRC checksum.
    ]];

    if(hAssembly.assembled)then
        CRC = hAssembly(szString, szString:len(), CRC); -- Call the CRC code
    else
        local asmError = hAssembly:GetError();
        if(asmError)then
            if(asmError.errorCode ~= 0)then -- If it wasn't successful and errorCode is 0, then you probably tried assembling an empty block.
                Dialog.Message("Assembler error: "..tostring(asmError.errorCode), "Line "..tostring(asmError.errorLine)..": "..asmError.errorMessage.."\r\nCode at line: "..asmError.errorLineString);
            end
        end
    end

    hAssembly:Free();

    return CRC;
end

-- Check if your processor supports the SSE2 instruction set.
local function CPU_SSE2()
    local sse2 = false;
    local hAssembly = ASM.Assemble[[
        USE32                       ;-- Important, use 32 bits. Don't use USE16 and USE64, this is a 32 bit application!
        ORG     100h                ;-- The base

        MOV    EAX, 1h
        CPUID
        TEST   ECX, 2000000h
        JNZ    @F
            MOV EAX,   0
        @@:
            MOV EAX,   1

        RETN                        ;-- return, the value in EAX is usually returned to the calling process.
    ]];

    if(hAssembly.assembled)then
        sse2 = (hAssembly() == 1);
    else
        local asmError = hAssembly:GetError();
        if(asmError)then
            if(asmError.errorCode ~= 0)then -- If it wasn't successful and errorCode is 0, then you probably tried assembling an empty block.
                Dialog.Message("Assembler error: "..tostring(asmError.errorCode), "Line "..tostring(asmError.errorLine)..": "..asmError.errorMessage.."\r\nCode at line: "..asmError.errorLineString);
            end
        end
    end

    hAssembly:Free();

    return sse2;
end

asm_test_1();
asm_test_2();
print(CPU_SSE2())

local crc = CRC32("Hello World!!");
print("CRC32 of \"Hello World!!\"", crc, "("..tostring(Bitwise.And(crc, 0xFFFFFFFF)).." unsigned)");