-- init IP list with our first IP
local IPL = {
    {
        id = 1,
        IP = {0,0},
        delta = {1,0},
        SO = {0, 0},
        SS = {{}}
    }
}
local IPLi = 1 -- indicates the index of the current IP in IPL
local nextID = 2; -- so we can keep the IDs unique even if the highest ends and a new one is made
local FS = { [0] = {}} -- funge sapce
--init some registers
local Ax, Bx
local stringmode = false
local oldseed = os.time() --initialize random seed
local extents = {{0,0},{0,0}}

-- instruction queue
IQ = {
    [10] = function()
            io.write("\n")
        end,
    [32] = function()
            advance()
            local instruction = fetch()
            local code = decode(instruction)
            execute(code)
        end,
    [33] = function()
            Ax = pop()
            if Ax == 0 then
                Ax = 1
            else
                Ax = 0
            end
            push(Ax)
        end,
    [34] = function()
            stringmode = not stringmode
        end,
    [35] = function()
            advance()
        end,
    [36] = function()
            pop()
        end,
    [37] = function()
            Ax = pop()
            Bx = pop()
            if Ax ~= 0 then
                push(Bx % Ax)
            else
                push(0)
            end
        end,
    [38] = function()
            Ax = io.read(1)
            if string.match(Ax,"%d") then
                push(Ax)
            else
                execute(38)
            end
        end,
    [39] = function()
            advance()
            push(decode(fetch()))
        end,
    [42] = function()
            Ax = pop()
            Bx = pop()
            push(Bx * Ax)
        end,
    [43] = function()
            Ax = pop()
            Bx = pop()
            push(Bx + Ax)
        end,
    [44] = function()
            Ax = pop()
            if Ax > 0 then
                io.write(string.char(Ax))
            end
        end,
    [45] = function()
            Ax = pop()
            Bx = pop()
            push(Bx - Ax)
        end,
    [46] = function()
            Ax = pop()
            io.write(Ax)
            io.write(" ")
        end,
    [47] = function()
            Ax = pop()
            Bx = pop()
            if Ax ~= 0 then
                push(math.floor(Bx / Ax))
            else
                push(0)
            end
        end,
    [48] = function()
            push(0)
        end,
    [49] = function()
            push(1)
        end,
    [50] = function()
            push(2)
        end,
    [51] = function()
            push(3)
        end,
    [52] = function()
            push(4)
        end,
    [53] = function()
            push(5)
        end,
    [54] = function()
            push(6)
        end,
    [55] = function()
            push(7)
        end,
    [56] = function()
            push(8)
        end,
    [57] = function()
            push(9)
        end,
    [58] = function()
            Ax = pop()
            push(Ax)
            push(Ax)
        end,
    [59] = function()
            local code = ""
            while code ~= 59 do --find next ;
                advance()
                code = decode(fetch())
            end
            --advance past ; and execute command
            advance()
            execute(decode(fetch()))
        end,
    [60] = function()
            IPL[IPLi].delta = {-1,0}
        end,
    [61] = function()
            local cmd = ""
            Ax = pop()
            while Ax ~= 0 do
                cmd = cmd .. string.char(Ax)
                Ax = pop()
            end
            push(os.execute(cmd))
        end,
    [62] = function()
            IPL[IPLi].delta = {1, 0}
        end,
    [63] = function()
            math.randomseed(oldseed)
            oldseed = oldseed * math.random(1000000)
            local num = math.floor(math.random(1,4))
            local deltas = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}}
            IPL[IPLi].delta = deltas[num]
        end,
    [64] = function()
            table.remove(IPL,IPLi)
            IPLi = IPLi - 1
        end,
    [91] = function()
            local curdelta = deepcopy(IPL[IPLi].delta)
            IPL[IPLi].delta[1] = curdelta[2]
            IPL[IPLi].delta[2] = curdelta[1] * -1
        end,
    [92] = function()
            Ax = pop()
            Bx = pop()
            push(Ax)
            push(Bx)
        end,
    [93] = function()
            local curdelta = deepcopy(IPL[IPLi].delta)
            IPL[IPLi].delta[2] = curdelta[1]
            IPL[IPLi].delta[1] = curdelta[2] * -1
        end,
    [94] = function()
            IPL[IPLi].delta = {0, -1}
        end,
    [95] = function()
            Ax = pop()
            if Ax ~= 0 then
                IPL[IPLi].delta = {-1, 0}
            else
                IPL[IPLi].delta = {1, 0}
            end
        end,
    [96] = function()
            Ax = pop()
            Bx = pop()
            if Ax > Bx then
                push(0)
            else
                push(1)
            end
        end,
    [97] = function()
            push(10)
        end,
    [98] = function()
            push(11)
        end,
    [99] = function()
            push(12)
        end,
    [100] = function()
            push(13)
        end,
    [101] = function()
            push(14)
        end,
    [102] = function()
            push(15)
        end,
    [103] = function()
            Ax = pop()
            Bx = pop()
            local char = FS[IPL[IPLi].SO[1] + Ax][IPL[IPLi].SO[2] + Bx]
            push(string.byte(char))
        end,
    [106] = function()
            Ax = pop()
            for i = 1, Ax do
                advance()
            end
        end,
    [107] = function()
            local i = pop()
            advance()
            local code = decode(fetch())
            while i > 0 do
                if code == 32 or code == 59 then
                    execute(code)
                    code = decode(fetch())
                else
                    execute(code)
                end
                i = i - 1
            end
        end,
    [110] = function()
            while #IPL[IPLi].SS[1] > 0 do
                pop()
            end
        end,
    [112] = function()
            Ax = pop()
            Bx = pop()
            local char = string.char(pop())
            if FS[IPL[IPLi].SO[1] + Ax] == nil then
                FS[IPL[IPLi].SO[1] + Ax] = {}
            end
            FS[IPL[IPLi].SO[1] + Ax][IPL[IPLi].SO[2] + Bx] = char
        end,
    [113] = function()
            Ax = pop()
            os.exit(Ax)
        end,
    [114] = function()
            IPL[IPLi].delta[1] = IPL[IPLi].delta[1] * -1
            IPL[IPLi].delta[2] = IPL[IPLi].delta[2] * -1
        end,
    [115] = function()
            Ax = pop()
            advance()
            FS[IPL[IPLi].IP[1]][IPL[IPLi].IP[2]] = string.char(Ax)
        end,
    [116] = function()
            local IP = {}
            IP.id = nextID
            nextID = nextID + 1
            IP.delta = {IPL[IPLi].delta[1] * -1, IPL[IPLi].delta[2] * -1}
            IP.IP = {IPL[IPLi].IP[1] + IP.delta[1], IPL[IPLi].IP[2] + IP.delta[2]}
            IP.SO = {IPL[IPLi].SO[1], IPL[IPLi].SO[2]}
            IP.SS = deepcopy(IPL[IPLi].SS)
            table.insert(IPL,IPLi,IP)
            IPLi = IPLi + 1
        end,
    [118] = function()
            IPL[IPLi].delta = {0, 1}
        end,
    [119] = function()
            Ax = pop()
            Bx = pop()
            if Ax > Bx then
                execute(91)
            elseif Ax < Bx then
                execute(93)
            else
                execute(122)
            end
        end,
    [120] = function()
            Ax = pop()
            Bx = pop()
            IPL[IPLi].delta = {Bx, Ax}
        end,
    [121] = function()
            Ax = pop()
            if Ax < 1 then

            end
        end,
    [122] = function()
            --do nothing
        end,
    [124] = function()
            Ax = pop()
            if Ax == 0 then
                IPL[IPLi].delta = {0, 1}
            else
                IPL[IPLi].delta = {0, -1}
            end
        end;
    [126] = function()
            push(decode(io.read(1)))
        end;
}

function deepcopy(curTable)
    local duptable = {}
    for i, v in pairs(curTable) do
        if type(v) == "table" then
            duptable[i] = deepcopy(v)
        else
            duptable[i] = v
        end
    end
    return duptable
end

function push(v)
    table.insert(IPL[IPLi].SS[1],v)
end

function pop()
    if IPL[IPLi].SS[1][1] then
        return table.remove(IPL[IPLi].SS[1])
    else
        return 0
    end
end

function advance()
    if #IPL > 0 then
        IPL[IPLi].IP[1] = IPL[IPLi].IP[1] + IPL[IPLi].delta[2] --deltas are switched to change between the way we
        IPL[IPLi].IP[2] = IPL[IPLi].IP[2] + IPL[IPLi].delta[1] --think of coordinates and the way tables are indexed
        if IPL[IPLi].IP[1] > extents[2][1] then
            IPL[IPLi].IP[1] = extents[1][1]
        elseif IPL[IPLi].IP[1] < extents[1][1] then
            IPL[IPLi].IP[1] = extents[2][1]
        end
        if IPL[IPLi].IP[2] > extents[2][2] then
            IPL[IPLi].IP[2] = extents[1][2]
        elseif IPL[IPLi].IP[2] < extents[1][2] then
            IPL[IPLi].IP[2] = extents[2][2]
        end
    end
end

function fetch()
    return FS[IPL[IPLi].IP[1]][IPL[IPLi].IP[2]]
end

function decode(char)
    if char == nil then
        char = " "
    end
    return string.byte(char)
end

function execute(code)
    if IQ[code] then
        IQ[code]()
    else
        IQ[114]()
    end
end

local function run(funge)
    local i = 0
    local j = 0
    --load funge into fungespace
    for c = 1, #funge do
        local char = string.sub(funge,c,c)
        if (char ~= '\n') then
            table.insert(FS[i], j, char)
            if j > extents[2][2] then
                extents[2][2] = j
            end
            j = j + 1
        else
            i = i + 1
            table.insert(FS, i, {})
            if i > extents[2][1] then
                extents[2][1] = i
            end
            j = 0
        end
    end


    --start main loop
    while #IPL > 0 do  --while there is a running IP
        IPLi = 1  --start at first IP
        while IPLi <= #IPL do  --cycle through IP list

            --fetch
            local instruction = fetch()

            --decode
            local code = decode(instruction)

            --execute
            if (not stringmode) or code == 34 then
                execute(code)
            else
                push(code)
                --consolidate concurrent spaces
                if code == 32 then
                    while FS[IPL[IPLi].IP[1] + IPL[IPLi].delta[2]][IPL[IPLi].IP[2] + IPL[IPLi].delta[1]] == " " do
                        IPL[IPLi].IP[1] = IPL[IPLi].IP[1] + IPL[IPLi].delta[2]
                        IPL[IPLi].IP[2] = IPL[IPLi].IP[2] + IPL[IPLi].delta[1]
                    end
                end
            end

            --advance IP
            advance()

            --next IP
            IPLi = IPLi + 1
        end
    end
end