section .data

    R       EQU 32
    M1      EQU 3
    M2      EQU 24
    M3      EQU 10

    %macro  mat3pos 0

        push    eax
        shr     eax, cl
        pop     ecx
        xor     eax, ecx

    %endmacro

    %macro  mat3neg 0

        push    eax
        shl     eax, cl
        pop     ecx
        xor     eax, ecx

    %endmacro

section .bss

    z0      resd 1
    z1      resd 1
    z2      resd 1
    state_n resd 1

    STATE   resd R

    seed    resd R

section .text

    global _start

    init_WELL:

        push    ebp
        mov     ebp, esp
        push    ebx

        lea     esi, [ebp + 8]
        mov     edi, STATE

        xor ebx, ebx

    init_WELL_loop:

        mov     eax, [esi + ebx * 4]
        mov     [edi + ebx * 4], eax
        inc     ebx

        cmp     ebx, R
        jb      init_WELL_loop

        pop     ebx
        mov     esp, ebp
        pop     ebp
        ret

    well1024a:

        mov     esi, STATE              ; Storing STATE for easy access.

        mov     ebx, [state_n]          ; Computing z0
        add     ebx, 31
        and     ebx, 0000001fh
        mov     eax, [esi + ebx * 4]
        mov     [z0], eax

        mov     ebx, [state_n]          ; Computing I(V0) ^ MAT3POS(8, VM1).
        mov     eax, [esi + ebx * 4]
        push    eax

        add     ebx, M1                 ; EBX is already state_n, adding M1.
        and     ebx, 0000001fh
        mov     eax, [esi + ebx * 4]
        mov     cl, 8
        mat3pos

        pop     ebx
        xor     eax, ebx
        mov     [z1], eax

        mov     ebx, [state_n]          ; Computing MAT3NEG(-19,VM2) ^ MAT3NEG(-14,VM3)
        add     ebx, M2
        and     ebx, 0000001fh
        mov     eax, [esi + ebx * 4]
        mov     cl, 19
        mat3neg
        push    eax

        mov     ebx, [state_n]
        add     ebx, M3
        and     ebx, 0000001fh
        mov     eax, [esi + ebx * 4]
        mov     cl, 14
        mat3neg

        pop     ebx
        xor     eax, ebx
        mov     [z2], eax

        mov     ebx, [state_n]          ; Computing z1 ^ z2
        lea     edi, [esi + ebx * 4]

        mov     eax, [z1]
        xor     eax, [z2]

        mov     [edi], eax

        mov     ebx, [state_n]          ; Computing M3N(-11,z0)^M3N(-1,z1)^M3N(-13,z2)
        add     ebx, 31
        and     ebx, 0000001fh
        lea     edi, [esi + ebx * 4]

        mov     eax, [z0]
        mov     cl, 11
        mat3neg
        push    eax

        mov     eax, [z1]
        mov     cl, 7
        mat3neg
        push    eax

        mov     eax, [z2]
        mov     cl, 13
        mat3neg

        pop     ebx
        pop     ecx
        xor     ebx, ecx
        xor     eax, ebx
        mov     [edi], eax

        mov     eax, [state_n]          ; Shifting state_n
        add     eax, 31
        and     eax, 0000001fh
        mov     [state_n], eax

        lea     ecx, [esi + eax * 4]    ; Return.
        mov     eax, 4                  ; sys_write
        mov     ebx, 1                  ; stdout
        mov     edx, 4                  ; 4 bytes
        int     80h

        jmp     well1024a


    _start:

        xor     edi, edi

    read_loop:

        mov     eax, 3                  ; sys_read
        mov     ebx, 0                  ; stdin
        lea     ecx, [seed + edi]       ; Store input to seed
        mov     edx, R * 4              ; Read at most R*4 bytes.
        sub     edx, edi
        int     80h

        add     edi, eax
        cmp     edi, R * 4
        jb      read_loop

        push    seed
        call    init_WELL
        add     esp, 4

        jmp     well1024a