[CC] Chiper v3FINAL

local bckColLast = term.getBackgroundColor()
local txtColLast = term.getTextColor()

local tArgs = { ... }
local WIDTH, HEIGHT = term.getSize()
local COLS = {
    [ 0x0 ] = 0x1;
    [ 0x1 ] = 0x2;
    [ 0x2 ] = 0x4;
    [ 0x3 ] = 0x8;
    [ 0x4 ] = 0x10;
    [ 0x5 ] = 0x20;
    [ 0x6 ] = 0x40;
    [ 0x7 ] = 0x80;
    [ 0x8 ] = 0x100;
    [ 0x9 ] = 0x200;
    [ 0xA ] = 0x400;
    [ 0xB ] = 0x800;
    [ 0xC ] = 0x1000;
    [ 0xD ] = 0x2000;
    [ 0xE ] = 0x4000;
    [ 0xF ] = 0x8000;
}

local function inputStream( input )
    if fs.exists( input ) then
        local file = fs.open( input, 'r' )
        input = file.readAll()
        file.close()
    else
        error( "File: "..input.." does not exist!", 0 )
    end
    input=input.."\n"
    local i = 1
    local line = 1
    return {
        [ "next" ] = function()
            local v = input:sub( i, i )
            if v == "\n" then
                line = line + 1
            end
            i = i + 1
            return v
        end;
        [ "peek" ] = function()
            return input:sub( i, i )
        end;
        [ "eof" ] = function()
            return i > #input
        end;
        [ "setPos" ] = function( pos )
            i = pos
        end;
        [ "error" ] = function( msg )
            error( tArgs[1]..":"..line..": "..msg, 0 )
        end;
    }
end

local function tokenize( input )
    local function isId( c )
        return c:match( "[a-zA-Z]" ) ~= nil
    end
    local function isNum( c )
        return c:match( "[0-9]" ) ~= nil
    end
    local function isPunc( c )
        return c:match( "[,$#%(%).]" ) ~= nil
    end
    local function isWht( c )
        return c:match( "[ \t\n]" ) ~= nil
    end

    local function readWhile( p )
        local str = ""
        while input.eof() == false and p( input.peek() ) do
            str = str .. input.next()
        end
        return str
    end
    local function String()
        input.next()
        local str = readWhile( function( p ) return p ~= "\"" end )
        input.next()
        return {
            [ "type" ] = "str";
            [ "value" ] = str;
        }
    end
    local function Id()
        return {
            [ "type" ] = "id";
            [ "value" ] = readWhile( function( p )
                return isNum( p ) or isId( p )
            end ):upper();
        }
    end
    local function Num()
        return {
            [ "type" ] = "num";
            [ "value" ] = readWhile( function( p )
                return isNum( p ) or isId( p )
            end );
        }
    end
    local function Punc()
        return {
            [ "type" ] = "pnc";
            [ "value" ] = input.next();
        }
    end
    local function Comment()
        input.next()
        readWhile( function( p )
            return p ~= "\n"
        end )
        readWhile( isWht )
        if input.peek() == ";" then
            Comment()
        end
    end

    local function Next()
        readWhile( isWht )
        local p = input.peek()
        if p == ";" then
            Comment()
            p = input.peek()
        end
        if isNum( p ) then
            return Num()
        elseif isId( p ) then
            return Id()
        elseif isPunc( p ) then
            return Punc()
        elseif p == "" then
            return {
                [ "type" ] = "EOF";
            }
        elseif p == "\"" then
            return String()
        end
        error( "unexpected char: "..p.." "..#p )
    end

    local curr
    return {
        [ "next" ] = function()
            local v = curr
            curr = nil
            return v or Next()
        end;
        [ "peek" ] = function()
            if curr then
                return curr
            else
                curr = Next()
                return curr
            end
        end;
        [ "eof" ] = input.eof;
        [ "setPos" ] = function( pos )
            input.setPos( pos )
            curr = nil
        end;
        [ "error" ] = input.error;
    }
end

local MNEMONICS = {
    [ "HLT" ] = 0;
    [ "RET" ] = 0;
    [ "CALL" ] = 1;
    [ "JMP" ] = 1;
    [ "LD" ] = 2;
    [ "ADD" ] = 2;
    [ "SUB" ] = 2;
    [ "MUL" ] = 2;
    [ "EQL" ] = 2;
    [ "MEQ" ] = 2;
    [ "MOR" ] = 2;
    [ "LEQ" ] = 2;
    [ "LES" ] = 2;
}
local ACCEPTED = {}
local VirtualMemory = {}

local function parse( input )
    local bc = 0
    local DataStart = 0xFF0
    local function parseLabels()
        while input.eof() == false do
            if input.peek().type == "pnc" then
                if input.peek().value == "." then
                    input.next()
                    local name = input.next()
                    if name.type == "id" then
                        if input.peek().value == "DB" then
                            input.next()
                            local data = input.next()
                            if data.type == "str" then
                                ACCEPTED[ name.value ] = DataStart-1
                                local d = data.value
                                for i=1, #d do
                                    VirtualMemory[ DataStart ] = {string.byte( d:sub( i, i ) )}
                                    DataStart = DataStart - 1
                                end
                                VirtualMemory[ DataStart ] = 0
                                DataStart = DataStart - 1
                            elseif data.type == "pnc" and data.value == "$" then
                                if input.peek().type == "id" or input.peek().type == "num" then
                                    ACCEPTED[ name.value ] = DataStart-1
                                    VirtualMemory[ DataStart ] = {tonumber( "0x"..input.next().value )}
                                    DataStart = DataStart - 1
                                    VirtualMemory[ DataStart ] = 0
                                end
                            elseif data.type == "pnc" and data.value == "#" then
                                if input.peek().type == "id" or input.peek().type == "num" then
                                    ACCEPTED[ name.value ] = DataStart-1
                                    VirtualMemory[ DataStart ] = {tonumber( input.next().value )}
                                    DataStart = DataStart - 1
                                    VirtualMemory[ DataStart ] = 0
                                end
                            else
                                input.error("DB can be types of: String, Number!")
                            end
                        else
                            ACCEPTED[ name.value ] = bc
                        end
                    else
                        input.error("Expected id after '.'(dot) label declaration!")
                    end
                else
                    input.next()
                end
            else
                parseMnemonic()
            end
        end
        input.setPos( 1 )
    end

    local function Arg()
        if input.peek().type == "id" then
            return {
                [ "type" ] = "reg";
                [ "value" ] = input.next().value;
            }
        elseif input.peek().type == "pnc" then
            if input.peek().value == "$" then
                input.next()
                if input.peek().type == "id" or input.peek().type == "num" then
                    return {
                        [ "type" ] = "num";
                        [ "value" ] = tonumber( "0x"..input.next().value );
                    }
                else
                    input.error( "Expected hexadecimal number!" )
                end
            elseif input.peek().value == "#" then
                input.next()
                if input.peek().type == "num" then
                    return {
                        [ "type" ] = "num";
                        [ "value" ] = tonumber( input.next().value );
                    }
                else
                    input.error( "Expected numeric number!")
                end
            elseif input.peek().value == "(" then
                input.next()
                local arg = Arg()
                if input.peek().value == ")" then
                    input.next()
                else
                    input.error( "Expected ')'!" )
                end
                return {
                    [ "type" ] = "mem";
                    [ "value" ] = arg;
                }
            else
                input.error( "Expected number declaration '$' or '#' or memory location '(I)'!" )
            end
        else
            input.error( "No valid argument!" )
        end
    end

    function parseMnemonic()
        local p = input.peek()
        if p.type == "id" then
            if MNEMONICS[ p.value ] then
                p = input.next()
                local args = {}
                local size = MNEMONICS[ p.value ]
                if size > 0 then
                    for i=1, size do
                        args[#args+1] = Arg()
                        if size > 1 then
                            if i == 1 then
                                if input.peek().value == "," then
                                    input.next()
                                else
                                    input.error( "Expected ','(comma)" )
                                end
                            end
                        end
                    end
                end
                bc = bc + 2
                return {
                    [ "type" ] = "mnemonic";
                    [ "name" ] = p.value;
                    [ "args" ] = args;
                }
            else
                input.error("NOT A MNEMONIC!")
            end
        elseif p.type == "pnc" then
            if p.value == "." then
                input.next()
                input.next()
                if input.peek().value == "DB" then
                    input.next()
                    local _ = input.next()
                    if _.value == "$" or _.value == "#" then
                        input.next()
                    end
                end
            end
        end
    end
    parseLabels()
    local function Program()
        local prog = {}
        while input.eof() == false do
            prog[#prog+1] = parseMnemonic()
        end
        return {
            [ "type" ] = "program";
            [ "prog" ] = prog;
        }
    end

    return Program()
end

local function compile( input )
    if input.type == "program" then
        for i=1, #input.prog do
            local curr = compile( input.prog[i] )
            for j=1, #curr do
                VirtualMemory[ ((i*2)-2)+j ] = curr[j]
            end
        end
    elseif input.type == "mnemonic" then
        local args = {}
        for i=1, #input.args do
            args[#args+1] = compile( input.args[ i ] )
        end
        if input.name == "HLT" then
            return { 0x00, 0x00 }
        elseif input.name == "RET" then
            return { 0x00, 0xE0 }
        elseif input.name == "CALL" then
            if args[1].type == "reg" then
                if args[1].value == "I" then
                    return { 0x00, 0x0E }
                elseif ACCEPTED[ args[1].value ] then
                    return { 0x2, ACCEPTED[ args[1].value ] }
                else
                    error( "CALL compile error! Expected 'I' or Pointer", 0 )
                end
            elseif args[1].type == "num" then
                return { 0x2, args[1].value }
            end
        elseif input.name == "JMP" then
            if args[1].type == "num" then
                return { 0x1, args[1].value }
            elseif args[1].type == "reg" then
                return { 0x1, ACCEPTED[ args[1].value ] }
            else
                error( "JMP compile error! Expected 'I' or Pointer", 0 )
            end
        elseif input.name == "LD" then
            if args[1].type == "reg" then
                if args[1].value == "A" and args[2].type == "num" then
                    return { 0x30, args[2].value }
                elseif args[1].value == "B" and args[2].type == "num" then
                    return { 0x40, args[2].value }
                elseif args[1].value == "B" and args[2].value == "RND" then
                    return { 0x57, 0x00 }
                elseif args[1].value == "A" and args[2].type == "mem" then
                    return { 0x73, 0x00 }
                elseif args[1].value == "B" and args[2].type == "mem" then
                    return { 0x74, 0x00 }
                elseif args[1].value == "I" and args[2].type == "num" then
                    return { 0x8, args[2].value }
                elseif args[1].value == "I" and args[2].value == "X" then
                    return { 0x75, 0x00 }
                elseif args[1].value == "X" and args[2].type == "num" then
                    return { 0x9, args[2].value }
                elseif args[1].value == "X" and args[2].value == "I" then
                    return { 0x76, 0x00 }
                elseif args[1].value == "I" and args[2].type == "reg" then
                    if ACCEPTED[ args[2].value ] then
                        return { 0x8, ACCEPTED[ args[2].value ] }
                    else
                        error(args[2].value.." not defined!",0)
                    end
                elseif args[1].value == "X" and args[2].type == "reg" then
                    if ACCEPTED[ args[2].value ] then
                        return { 0x9, ACCEPTED[ args[2].value ] }
                    else
                        error(args[2].value.." not defined!",0)
                    end
                end
            elseif args[1].type == "mem" and args[2].value == "A" then
                return { 0x70, 0x00 }
            elseif args[1].type == "mem" and args[2].value == "B" then
                return { 0x71, 0x00 }
            elseif args[1].type == "mem" and args[2].type == "num" then
                return { 0x72, args[2].value }
            else
                error( "LD compile error!",0 )
            end
        elseif input.name == "ADD" then
            if args[1].type == "reg" then
                if args[1].value == "A" and args[2].type == "num" then
                    return { 0x50, args[2].value }
                elseif args[1].value == "A" and args[2].value == "B" then
                    return { 0x51, 0x00 }
                elseif args[1].value == "B" and args[2].type == "num" then
                    return { 0x52, args[2].value }
                elseif args[1].value == "B" and args[2].value == "A" then
                    return { 0x53, 0x00 }
                elseif args[1].value == "I" and args[2].type == "num" then
                    return { 0x54, args[2].value }
                elseif args[1].value == "I" and args[2].value == "A" then
                    return { 0x55, 0x00 }
                elseif args[1].value == "I" and args[2].value == "B" then
                    return { 0x56, 0x00 }
                elseif args[1].value == "X" and args[2].type == "num" then
                    return { 0xA0, args[2].value }
                elseif args[1].value == "X" and args[2].value == "A" then
                    return { 0xA1, 0x00 }
                elseif args[1].value == "X" and args[2].value == "B" then
                    return { 0xA2, 0x00 }
                end
            else
                error( "ADD compile error!",0 )
            end
        elseif input.name == "SUB" then
            if args[1].type == "reg" then
                if args[1].value == "A" and args[2].type == "num" then
                    return { 0x58, args[2].value }
                elseif args[1].value == "A" and args[2].value == "B" then
                    return { 0x59, 0x00 }
                elseif args[1].value == "B" and args[2].type == "num" then
                    return { 0x5A, args[2].value }
                elseif args[1].value == "B" and args[2].value == "A" then
                    return { 0x5B, 0x00 }
                elseif args[1].value == "X" and args[2].type == "num" then
                    return { 0xA3, args[2].value }
                elseif args[1].value == "X" and args[2].value == "A" then
                    return { 0xA4, 0x00 }
                elseif args[1].value == "X" and args[2].value == "B" then
                    return { 0xA5, 0x00 }
                end
            else
                error( "SUB compile error!",0 )
            end
        elseif input.name == "MUL" then
            if args[1].type == "reg" then
                if args[1].value == "A" and args[2].type == "num" then
                    return { 0x5C, args[2].value }
                elseif args[1].value == "A" and args[2].value == "B" then
                    return { 0x5D, 0x00 }
                elseif args[1].value == "B" and args[2].type == "num" then
                    return { 0x5E, args[2].value }
                elseif args[1].value == "B" and args[2].value == "A" then
                    return { 0x5F, 0x00 }
                elseif args[1].value == "X" and args[2].type == "num" then
                    return { 0xA6, args[2].value }
                elseif args[1].value == "X" and args[2].value == "A" then
                    return { 0xA7, 0x00 }
                elseif args[1].value == "X" and args[2].value == "B" then
                    return { 0xA8, 0x00 }
                end
            else
                error( "MUL compile error!",0 )
            end
        elseif input.name == "EQL" then
            if args[1].type == "reg" then
                if args[1].value == "A" and args[2].value == "B" then
                    return { 0x60, 0x00 }
                elseif args[1].value == "A" and args[2].type == "num" then
                    return { 0x61, args[2].value }
                elseif args[1].value == "B" and args[2].type == "num" then
                    return { 0x62, args[2].value }
                end
            else
                error( "EQL compile error!",0 )
            end
        elseif input.name == "MEQ" then
            if args[1].type == "reg" then
                if args[1].value == "A" and args[2].value == "B" then
                    return { 0x63, 0x00 }
                elseif args[1].value == "A" and args[2].type == "num" then
                    return { 0x64, args[2].value }
                elseif args[1].value == "B" and args[2].type == "num" then
                    return { 0x65, args[2].value }
                end
            else
                error( "MEQ compile error!",0 )
            end
        elseif input.name == "LEQ" then
            if args[1].type == "reg" then
                if args[1].value == "RA" and args[2].value == "B" then
                    return { 0x66, 0x00 }
                elseif args[1].value == "A" and args[2].type == "num" then
                    return { 0x67, args[2].value }
                elseif args[1].value == "B" and args[2].type == "num" then
                    return { 0x68, args[2].value }
                end
            else
                error( "LEQ compile error!",0 )
            end
        elseif input.name == "MOR" then
            if args[1].type == "reg" then
                if args[1].value == "A" and args[2].value == "B" then
                    return { 0x69, 0x00 }
                elseif args[1].value == "A" and args[2].type == "num" then
                    return { 0x6A, args[2].value }
                elseif args[1].value == "B" and args[2].type == "num" then
                    return { 0x6B, args[2].value }
                end
            else
                error( "MOR compile error!",0 )
            end
        elseif input.name == "LES" then
            if args[1].type == "reg" then
                if args[1].value == "A" and args[2].value == "B" then
                    return { 0x6C, 0x00 }
                elseif args[1].value == "A" and args[2].type == "num" then
                    return { 0x6D, args[2].value }
                elseif args[1].value == "B" and args[2].type == "num" then
                    return { 0x6E, args[2].value }
                end
            else
                error( "LES compile error!",0 )
            end
        end
    elseif input.type == "reg" or input.type == "num" then
        return input
    elseif input.type == "mem" then
        return {
            [ "type" ] = "mem";
            [ "value" ] = input.value.value;
        }
    end
end

local function makeByteFile( b, f )
    local file = fs.open( f, 'wb' )
    for i=1, 0xFFF-1, 2 do
        if VirtualMemory[ i ] then
            local b = { VirtualMemory[i] or 0, VirtualMemory[i+1] or 0 }
            local byte
            if b[1] == 0x8 or b[1] == 0x9 or b[1] == 0x1 or b[1] == 0x2 then
                byte = bit.bor( bit.blshift( b[1], 12 ), b[2] )
            else
                if type(b[1]) == "table" then
                    b[1] = b[1][1]
                end
                if type(b[2]) == "table" then
                    b[2] = b[2][1]
                end
                byte = bit.bor( bit.blshift( b[1], 8 ), b[2] )
            end
            if byte then
                file.write( bit.brshift( bit.band( byte, 0xFF00 ), 8 ) )
                file.write( bit.band( byte, 0xFF ) )
            end
        else
            file.write( 0 )
            file.write( 0 )
        end
    end
    file.close()
end

local rPC = 0
local SP = 0
local rA = 0
local rB = 0
local rI = 0
local rX = 0
local MEM = {}
local STACK = {}
local Running = false
local scrBuff = {}

local function reset()
    Running = true
    for i=0, 0xFFF do
        MEM[ i ] = 0
    end
    for i=0, 0xF do
        STACK[ i ] = 0
    end
    SP = 0
    rPC = 0
    rA = 0
    rB = 0
    rI = 0
    rX = 0
    for i=0, (WIDTH*HEIGHT)-1 do
        scrBuff[ i ] = {
            " ",
            COLS[ 1 ],
            COLS[ 0 ]
        }
    end
end

local _bor, _band, _lshift, _rshift = bit.bor, bit.band, bit.blshift, bit.brshift
local mrAndom = math.random

local function fetch()
    local opcode = _bor( _lshift( MEM[ rPC ], 8 ), MEM[ rPC + 1 ] )
    rPC = rPC + 2
    return opcode
end

local function wrapRegs()
    rA = rA % (0xFF+1)
    rB = rB % (0xFF+1)
    rI = rI % (0xFFF+1)
    rX = rX % (0xFFF+1)
    rPC = rPC % (0xFFF+1)
    if rA < 0 then rA = 0xFF end
    if rB < 0 then rB = 0xFF end
    if rI < 0 then rI = 0xFFF end
    if rX < 0 then rX = 0xFFF end
end

local function decode( opcode )
    local op = _band( opcode, 0xF000 )
    if op == 0x0000 then
        op = _band( opcode, 0xFF )
        if op == 0x00 then
            Running = false
            return
        elseif op == 0xE0 then
            SP = SP - 1
            rPC = STACK[ SP ]
            return
        elseif op == 0x0E then
            STACK[ SP ] = rPC
            SP = SP + 1
            rPC = rI
            return
        end
    elseif op == 0x1000 then
        rPC = _band( opcode, 0xFFF )
        return
    elseif op == 0x2000 then
        STACK[ SP ] = rPC
        SP = SP + 1
        rPC = _band( opcode, 0xFFF )
        return
    elseif op == 0x3000 then
        rA = _band( opcode, 0xFF )
        return
    elseif op == 0x4000 then
        rB = _band( opcode, 0xFF )
        return
    elseif op == 0x5000 then
        local hl = _band( _rshift( opcode, 8 ), 0xF )
        if hl == 0x0 then
            rA = rA + _band( opcode, 0xFF )
            return
        elseif hl == 0x1 then
            rA = rA + rB
            return
        elseif hl == 0x2 then
            rB = rB + _band( opcode, 0xFF )
            return
        elseif hl == 0x3 then
            rB = rB + rA
            return
        elseif hl == 0x4 then
            rI = rI + _band( opcode, 0xFF )
            return
        elseif hl == 0x5 then
            rI = rI + rA
            return
        elseif hl == 0x6 then
            rI = rI + rB
            return
        elseif hl == 0x7 then
            rB = mrAndom( 0, 0xFF )
            return
        elseif hl == 0x8 then
            rA = rA - _band( opcode, 0xFF )
            return
        elseif hl == 0x9 then
            rA = rA - rB
            return
        elseif hl == 0xA then
            rB = rB - _band( opcode, 0xFF )
            return
        elseif hl == 0xB then
            rB = rB - rA
            return
        elseif hl == 0xC then
            rA = rA * _band( opcode, 0xFF )
            return
        elseif hl == 0xD then
            rA = rA * rB
            return
        elseif hl == 0xE then
            rB = rB * _band( opcode, 0xFF )
            return
        elseif hl == 0xF then
            rB = rB * rA
            return
        end
    elseif op == 0x6000 then
        local hl = _band( _rshift( opcode, 8 ), 0xF )
        if hl == 0x0 then
            if (rA == rB) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0x1 then
            if (rA == _band( opcode, 0x00FF )) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0x2 then
            if (rB == _band( opcode, 0xFF )) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0x3 then
            if (rA >= rB) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0x4 then
            if (rA >= _band( opcode, 0xFF )) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0x5 then
            if (rB >= _band( opcode, 0xFF )) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0x6 then
            if (rA <= rB) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0x7 then
            if (rA <= _band( opcode, 0xFF )) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0x8 then
            if (rB <= _band( opcode, 0xFF )) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0x9 then
            if (rA > rB) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0xA then
            if (rA > _band( opcode, 0xFF )) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0xB then
            if (rB > _band( opcode, 0xFF )) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0xC then
            if (rA < rB) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0xD then
            if (rA < _band( opcode, 0xFF )) == false then
                rPC = rPC + 2
            end
            return
        elseif hl == 0xE then
            if (rB < _band( opcode, 0xFF )) == false then
                rPC = rPC + 2
            end
            return
        end
    elseif op == 0x7000 then
        local hl = _band( _rshift( opcode, 8 ), 0xF )
        if hl == 0 then
            MEM[ rI ] = rA
            return
        elseif hl == 1 then
            MEM[ rI ] = rB
            return
        elseif hl == 2 then
            MEM[ rI ] = _band( opcode, 0xFF )
            return
        elseif hl == 3 then
            rA = MEM[ rI ]
            return
        elseif hl == 4 then
            rB = MEM[ rI ]
            return
        elseif hl == 5 then
            rX = rI
            return
        elseif hl == 6 then
            rI = rX
            return
        end
    elseif op == 0x8000 then
        rI = _band( opcode, 0xFFF )
        return
    elseif op == 0x9000 then
        rX = _band( opcode, 0xFFF )
        return
    elseif op == 0xA000 then
        local hl = _band( _rshift( opcode, 8 ), 0xF )
        if hl == 0x0 then
            rX = rX + _band( opcode, 0xFF )
            return
        elseif hl == 0x1 then
            rX = rX + rA
            return
        elseif hl == 0x2 then
            rX = rX + rB
            return
        elseif hl == 0x3 then
            rX = rX - _band( opcode, 0xFF )
            return
        elseif hl == 0x4 then
            rX = rX - rA
            return
        elseif hl == 0x5 then
            rX = rX - rB
            return
        elseif hl == 0x6 then
            rX = rX * _band( opcode, 0xFF )
            return
        elseif hl == 0x7 then
            rX = rX * rA
            return
        elseif hl == 0x8 then
            rX = rX * rB
            return
        end
    end
end

local function loadROM( fn )
    printError( "LOADING..." )
    local file = fs.open( fn, "rb" )
    local byte = file.read()
    local i = 0
    while byte ~= nil do
        MEM[ i ] = byte
        i = i + 1
        byte = file.read()
    end
    file.close()
    term.setTextColor( colors.green )
    print( "LOADED: '"..fn.."'!" )
end
local toChar = string.char
local mFloor = math.floor
local tSetPos = term.setCursorPos
local tTSetCol = term.setTextColor
local tBSetCol = term.setBackgroundColor
local tWrite = term.write
local osPull = coroutine.yield
local osQueue = os.queueEvent
local BUFFSIZE=(WIDTH*HEIGHT)-1
local function cycle()
    for i=1, 0x25 do
        decode( fetch() )
        if Running == false then break end
        wrapRegs()
        scrBuff[ ((MEM[ 0xFFB ]*WIDTH) + MEM[ 0xFFA ]) % BUFFSIZE ] = {
            toChar( MEM[ 0xFFE ] ),
            COLS[ MEM[ 0xFFD ] ],
            COLS[ MEM[ 0xFFC ] ]
        }
        if MEM[ 0xFFF ] == 1 then
            MEM[ 0xFFF ] = 0
            for i=0, BUFFSIZE do
                tSetPos( 1+(i % WIDTH), 1+mFloor( i / WIDTH ) )
                tBSetCol( scrBuff[ i ][ 3 ] )
                tTSetCol( scrBuff[ i ][ 2 ] )
                tWrite( scrBuff[ i ][ 1 ] )
            end
        end
    end
end

local KEYS = {
    -- P1
    [ keys.up ] = 0x1; -- UP
    [ keys.down ] = 0x2; -- DOWN
    [ keys.left ] = 0x3; -- LEFT
    [ keys.right ] = 0x4; -- RIGHT
    [  keys.a ] = 0x5; -- A
    [  keys.b ] = 0x6; -- B

    -- P2
    [  72 ] = 0x7; -- UP
    [  76 ] = 0x8; -- DOWN
    [  75 ] = 0x9; -- LEFT
    [  77 ] = 0xA; -- RIGHT
    [  51 ] = 0xB; -- A
    [  52 ] = 0xC; -- B
}

if #tArgs > 1 then
    makeByteFile( compile( parse( tokenize( inputStream( tArgs[ 1 ] ) ) ) ), tArgs[ 2 ] )
    term.setTextColor( colors.green )
    print( "COMPILED!" )
    return
end
reset()
loadROM( tArgs[ 1 ] )
local myTimer = os.startTimer( 0.01 )
while Running do
    local ev, val = osPull()
    if ev == "key" then
        MEM[ 0xFF9 ] = (KEYS[ val ] or 0)
    elseif ev == "key_up" then
        MEM[ 0xFF9 ] = 0
    elseif ev == "timer" then
        if val == myTimer then
            cycle()
            myTimer = os.startTimer( 0.01 )
        end
    elseif ev == "terminate" then
        break
    end
end
term.setBackgroundColor( bckColLast )
term.setTextColor( txtColLast )
term.setCursorPos( 1, 1 )
term.clear()
print( "Chiper stopped." )