vim.lua

--[[
    CCVIM - A Vim-like text editor for ComputerCraft computers.
    Copyright (C) 2021  Minater247

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
]]

local args = {...}

local validArgs = {
    "--version",
    "--term",  -- back-compatibility, ignored
    "-g",
    "--not-a-term",
}

local unimplementedArgs = {
    "--",
    "-v",
    "-e",
    "-E",
    "-s",
    "-d",
    "-y",
    "-R",
    "-Z",
    "-m",
    "-M",
    "-b",
    "-l",
    "-C",
    "-N",
    "-V",
    "-D",
    "-n",
    "-r",
    "-L",
    "-T",
    "--ttyfail",
    "-u",
    "--noplugin",
    "-p",
    "-o",
    "-O",
    "+",
    "--cmd",
    "-c",
    "-S",
    "-s",
    "-w",
    "-W",
    "-x",
    "--startuptime",
    "-i",
    "--clean",
    "-h",
    "--help"
}

local version = 0.733
local releasedate = "2022-05-19"

local fileExplorerVer = 0.12

local tab = require("/vim/lib/tab")
local argv = require("/vim/lib/args")
local str = require("/vim/lib/str")
local fil = require("/vim/lib/fil")
local keyseq = require("/vim/lib/keyseq")
local Trie = require("/vim/lib/trie")
local itertools = require("/vim/lib/itertools")
local monitor
local decargs = argv.pull(args, validArgs, unimplementedArgs) --DecodedArguments
local openfiles = {}
local wid, hig = term.getSize()
local running = true
local filelines = {}
local filename = ""
local currCursorX = 1
local currCursorY = 1
local newfile = false
local currFileOffset = 0 --AKA CurrYOffset
local currXOffset = 0
local oldx = nil
local copybuffer = ""
local copytype = nil
local jumpbuffer = {}
local jumpoffset = 0 --offset for t/T jumping before/after a letter
local currfile = 1
local fileContents = {}
local motd = false
local modeMappings = {
    n = Trie.new(),
    i = Trie.new(),
    c = Trie.new(),
    o = Trie.new(),
    x = Trie.new(),
}
local mappingCommands = {
    map = {mode = "", remap = true},
    ["map!"] = {mode = "!", remap = true},
    nmap = {mode = "n", remap = true},
    imap = {mode = "i", remap = true},
    cmap = {mode = "c", remap = true},
    omap = {mode = "o", remap = true},
    xmap = {mode = "x", remap = true},
    vmap = {mode = "x", remap = true},
    noremap = {mode = "", remap = false},
    ["noremap!"] = {mode = "!", remap = false},
    nnoremap = {mode = "n", remap = false},
    inoremap = {mode = "i", remap = false},
    cnoremap = {mode = "c", remap = false},
    onoremap = {mode = "o", remap = false},
    xnoremap = {mode = "x", remap = false},
    vnoremap = {mode = "x", remap = false},
}
local currentMode = "n"
local noremapFor = 0
local filetypearr = {}
local mobile = false
local linenumbers = false
local lineoffset = 0
local syntaxhighlighting = false
local oldXOffset = 0
local oldFileOffset = 0
local lowspec = false
local autoindent = false
local ignorecase = false
local lastSearchPos
local lastSearchLine
local sessionSearches = {}
local repeatCount0 = 0
local repeatCount1 = 1
local scrollOption = 10
local shiftWidth = 4
local modeMsg
local visualSelectionRendered
local visualModeState = {}  -- Stored as a text object
local typeahead = {}  -- String keys and pseudokeys
local typeaheadUpdates = {}  -- Mouse position updates
local inputProperties = {mouseX = 1, mouseY = 1, pasteData = ""}
local activeModifiers = {}
local prefixedModifiers = {}
local keyboards = {}
local useTmKeyboards = false
local actionsTrie = Trie.new()  -- Generic Normal-mode handlers
local motionsTrie = Trie.new()  -- Normal & operator-pending -mode 
local textObjectsTrie = Trie.new()  -- Only operator-pending-mode 
local visualActionsTrie = Trie.new()  -- Generic Visual-mode handlers 
local keyNamesTranslation = {
    backspace = "bs",
    enter = "cr",
    tab = "tab",  -- Consider setting to "esc"?
    numPadEnter = "cr",
    delete = "del",
    minus = "-",
    equals = "=",
    leftBracket = "[",
    rightBracket = "]",
    semiColon = ";",
    apostrophe = "'",
    grave = "`",
    backslash = "backslash",
    comma = ",",
    period = ".",
    slash = "/",
    multiply = "kmultiply",
    space = " ",
    one = "1",
    two = "2",
    three = "3",
    four = "4",
    five = "5",
    six = "6",
    seven = "7",
    eight = "8",
    nine = "9",
    zero = "0",
    numPadAdd = "kplus",
    numPadSubtract = "kminus",
    numPadDecimal = "kpoint",
    numPadEquals = "kequal",
    numPadComma = "kcomma",
    numPadDivide = "kdivide",
    numPad0 = "k0",
    numPad1 = "k1",
    numPad2 = "k2",
    numPad3 = "k3",
    numPad4 = "k4",
    numPad5 = "k5",
    numPad6 = "k6",
    numPad7 = "k7",
    numPad8 = "k8",
    numPad9 = "k9",
    yen = "\xa5",
    circumflex = "^",
    at = "@",
    colon = ":",
    underscore = "_",
}
local keyNames = {}
for k, v in pairs(keyNamesTranslation) do
    if keys[k] then
        keyNames[keys[k]] = v
    end
end
local builtinKeyCharacters = {
    lt = "<",
    space = " ",
    backslash = "\\",
    bar = "|",
    kmultiply = "*",
    kplus = "+",
    kminus = "-",
    kpoint = ".",
    kequal = "=",
    kcomma = ",",
    kdivide = "/",
    k0 = "0",
    k1 = "1",
    k2 = "2",
    k3 = "3",
    k4 = "4",
    k5 = "5",
    k6 = "6",
    k7 = "7",
    k8 = "8",
    k9 = "9",
}
local modifierNames = {
    [keys.leftCtrl] = "C",
    [keys.rightCtrl] = "C",
    [keys.leftAlt] = "A",
    [keys.rightAlt] = "A",
    [keys.leftShift] = "S",
    [keys.rightShift] = "S",
}
local modifierOrder = {"C", "A", "S"}
local ignoreHold = {}  -- Modifiers that can only be prefixed
local keyNormalisation = {
    ["<"] = "lt",
    -- [">"] = "gt",
    [" "] = "space",
    ["\\"] = "backslash",
    ["|"] = "bar",
    ["esc"] = "tab",
}
local mouseClickNames = {
    [1] = "leftmouse",
    [2] = "rightmouse",
    [3] = "middlemouse",
}

-- Instead of defaulting to monitor without "--term",
-- default to no monitor without "-g"
-- Because multiple vim instances can be running at the same time,
-- and the monitor can be often used by something else
if tab.find(args, "-g") or tab.find(args, "--not-a-term") then
    monitor = peripheral.find("monitor")
end

local function registerSimpleKeys(names)
    local _, k
    for _, k in ipairs(names) do
        keyNames[keys[k]] = k:lower()
    end
end
registerSimpleKeys{"left", "right", "up", "down"}
registerSimpleKeys{"f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"}
registerSimpleKeys{"home", "end", "pageUp", "pageDown", "insert"}
registerSimpleKeys{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"}

local function isCharacterKey(name)
    if #name == 1 then
        return true
    end
    if builtinKeyCharacters[name] ~= nil then
        return true
    end
    return false
end

local function getSelfInsert(name)
    if #name == 1 then
        return name
    end
    local ch = builtinKeyCharacters[name]
    if ch ~= nil then
        return ch
    end
    return "<" .. name .. ">"
end

local function registerAction(seq, cb)
    local key = keyseq.parseKeySequence(seq, keyNormalisation, modifierOrder)
    actionsTrie:put(key, cb)
end

local function registerActionMulti(components, getCb)
    for _, lst in itertools.product(components) do
        registerAction(table.concat(lst), getCb(lst))
    end
end

local function registerMotion(seq, opts, cb)
    local key = keyseq.parseKeySequence(seq, keyNormalisation, modifierOrder)
    motionsTrie:put(key, {cb, opts or {}})
end

local function registerMotionMulti(components, getOptsCb)
    for _, lst in itertools.product(components) do
        registerMotion(table.concat(lst), getOptsCb(lst))
    end
end

local function registerTextObject(seq, opts, cb)
    local key = keyseq.parseKeySequence(seq, keyNormalisation, modifierOrder)
    textObjectsTrie:put(key, {cb, opts or {}})
end

local function registerTextObjectMulti(components, getOptsCb)
    for _, lst in itertools.product(components) do
        registerTextObject(table.concat(lst), getOptsCb(lst))
    end
end

local function registerVisualAction(seq, cb)
    local key = keyseq.parseKeySequence(seq, keyNormalisation, modifierOrder)
    visualActionsTrie:put(key, cb)
end

local function registerVisualActionMulti(components, getCb)
    for _, lst in itertools.product(components) do
        registerVisualAction(table.concat(lst), getCb(lst))
    end
end

local function registerNormalVisualAction(seq, cb)
    registerAction(seq, cb)
    registerVisualAction(seq, function()
        currCursorX = visualModeState.x - currXOffset
        currCursorY = visualModeState.y - currFileOffset
        local result = cb() or false
        visualModeState.x = currCursorX + currXOffset
        visualModeState.y = currCursorY + currFileOffset
        return result
    end)
end

local function registerMapping(src, dst, opts)
    opts = opts or {}
    local srcArr = keyseq.parseKeySequence(src, keyNormalisation, modifierOrder)
    local dstArr = keyseq.parseKeySequence(dst, keyNormalisation, modifierOrder)
    local mode = opts.mode or ""
    if mode == "" then
        mode = "nox"
    elseif mode == "!" then
        mode = "ic"
    end
    local remap = opts.remap or false
    local entry = {
        dst = dstArr,
        remap = remap,
    }
    for m in mode:gmatch(".") do
        local trie = modeMappings[m]
        if trie ~= nil then
            trie:put(srcArr, entry)
        end
    end
end

local function getShiftWidth()
    if shiftWidth < 1 then
        return 1  -- tabstop is currently always 1
    end
    return shiftWidth
end

local function resetSize()
    if monitor then
        wid, hig = monitor.getSize()
    else
        wid, hig = term.getSize()
    end
end

local resetLastSearch

local function clear()
    if monitor then
        monitor.clear()
    else
        term.clear()
    end
end

local function setcolors(bg, txt)
    if monitor then
        monitor.setBackgroundColor(bg)
        monitor.setTextColor(txt)
    else
        term.setBackgroundColor(bg)
        term.setTextColor(txt)
    end
end

local function write(message)
    if monitor then
        monitor.write(message)
    else
        term.write(message)
    end
end

local function setpos(xpos, ypos)
    if monitor then
        monitor.setCursorPos(xpos, ypos)
    else
        term.setCursorPos(xpos, ypos)
    end
end

local function getLatestModifiers(...)  -- Example result: {A = true, C = nil}
    local result = {}
    local resetPrefixed = ... or false
    local k, v
    for k, v in pairs(activeModifiers) do
        if v then
            result[modifierNames[k]] = true
        end
    end
    for k, v in pairs(prefixedModifiers) do
        if v then
            result[modifierNames[k]] = true
            if resetPrefixed then
                prefixedModifiers[k] = nil
            end
        end
    end
    return result
end

local function insertTypeahead(charname, ...)
    local kwargs = ... or {}
    local update = kwargs.update or {}
    local index = kwargs.index or #typeahead + 1
    charname = keyseq.normalizeKey(charname, keyNormalisation, modifierOrder)
    table.insert(typeahead, index, charname)
    table.insert(typeaheadUpdates, index, update)
end

local function expandPaste(alwaysNoremap)
    local data = inputProperties.pasteData
    if not data then
        return
    end
    local noremap = alwaysNoremap or noremapFor > 0
    local length = 0
    for i, ch in itertools.enumerate(data:gmatch(".")) do
        insertTypeahead(ch, {index = i})
        length = i
    end
    if noremap then
        noremapFor = noremapFor + length
    end
end

local handleOsEvent
local handleNonInputEvent  -- implemented after dependencies are declared

local function waitForEvents()
    local e, s, v2, v3 = os.pullEvent()
    handleOsEvent(e, s, v2, v3)
end

function handleOsEvent(e, s, v2, v3)
    if e == "char" then
        local mods = getLatestModifiers(true)
        if mods.S then
            -- Do not add shift, because it should already be consumed by the key to char conversion
        end
        if mods.A then
            -- Warning: AltGr might generate unwanted alt modification
            s = "A-" .. s
        end
        if mods.C then
            s = "C-" .. s
        end
        insertTypeahead(s)
    elseif e == "key" then
        local translatedKey = keyNames[s]
        local translatedMod = modifierNames[s]
        if translatedKey ~= nil then
            translatedKey = keyNormalisation[translatedKey:lower()] or translatedKey
            -- Only if the key event will not be doubled by a char event
            if not isCharacterKey(translatedKey) or activeModifiers[keys.leftCtrl] or activeModifiers[keys.rightCtrl] then
                local mods = getLatestModifiers(true)
                if mods.S then
                    translatedKey = "S-" .. translatedKey
                end
                if mods.A then
                    translatedKey = "A-" .. translatedKey
                end
                if mods.C then
                    translatedKey = "C-" .. translatedKey
                end
                insertTypeahead(translatedKey)
            end
        elseif translatedMod ~= nil then
            if (v2 and not activeModifiers[s]) or ignoreHold[s] then
                -- If a key sends a repeat event without a start event,
                -- it will not send key_up
                prefixedModifiers[s] = not prefixedModifiers[s]
            else
                activeModifiers[s] = true
                if prefixedModifiers[s] then
                    prefixedModifiers[s] = nil  -- Repeated modifier presses remove the prefixed state
                else
                    prefixedModifiers[s] = not v2  -- Only prefixed if not held
                    -- FIXME repeats for the modifier keys seem to not be sent
                end
            end
        end
    elseif e == "key_up" then
        local translatedMod = modifierNames[s]
        if translatedMod ~= nil then
            activeModifiers[s] = nil  -- No longer active
            -- But remain prefixed
        end
    elseif e == "mouse_click" then
        local translatedKey = mouseClickNames[s]
        local mods = getLatestModifiers(true)
        if mobile or translatedKey == nil then
            translatedKey = "tab"
        else
            if mods.S then
                translatedKey = "S-" .. translatedKey
            end
            if mods.A then
                translatedKey = "A-" .. translatedKey
            end
            if mods.C then
                translatedKey = "C-" .. translatedKey
            end
        end
        insertTypeahead(translatedKey, {update = {mouseX = v2, mouseY = v3}})
    elseif e == "mouse_scroll" then
        local translatedKey = "scrollwheeldown"
        if s < 0 then
            translatedKey = "scrollwheelup"
        end
        local mods = getLatestModifiers(true)
        if mods.S then
            translatedKey = "S-" .. translatedKey
        end
        if mods.A then
            translatedKey = "A-" .. translatedKey
        end
        if mods.C then
            translatedKey = "C-" .. translatedKey
        end
        insertTypeahead(translatedKey, {update = {mouseX = v2, mouseY = v3}})
    elseif e == "paste" then
        -- Warning! Some implementations do not paste when alt or shift is help
        -- Prefix these modifiers to send them as a paste event for the program
        -- to receive the clipboard contents
        local translatedKey = "C-v"
        local mods = getLatestModifiers(true)
        if mods.S then
            translatedKey = "S-" .. translatedKey
        end
        if mods.A then
            translatedKey = "A-" .. translatedKey
        end
        insertTypeahead(translatedKey, {update = {pasteData = s}})
    else
        handleNonInputEvent(e, s, v2, v3)
    end
end

local function pullTypeahead()
    local key = table.remove(typeahead, 1)
    while key == nil and running do
        waitForEvents()
        key = table.remove(typeahead, 1)
    end
    local upd = table.remove(typeaheadUpdates, 1)
    itertools.update(inputProperties, upd)
    if noremapFor > 0 then
        noremapFor = noremapFor - 1
    end
    return key
end

local applyMappings

-- pull from typeahead with remaps
local function pullTypeaheadWRMP()
    applyMappings()
    local key = pullTypeahead()
    return key
end

local function peekTypeahead(idx)
    idx = idx or 1
    while #typeahead < idx do
        waitForEvents()
    end
    return typeahead[idx]
end

local function peekTypeaheadWRMP(idx)
    applyMappings()
    local key = peekTypeahead(idx)
    return key
end

local function typeaheadLength()
    return #typeahead
end

function applyMappings()
    while noremapFor < 1 do
        local trie = modeMappings[currentMode]
        if trie == nil then
            return
        end
        local i = 0
        local cons = trie:consumer()
        while true do
            i = i + 1
            local key = peekTypeahead(i)
            if not cons:next(key) then
                break
            end
            if not cons:hasNext() then
                break
            end
        end
        local len, entry = cons:getDeepest()
        if len > 0 then
            local dst = entry.dst or {}
            if #dst < 1 then
                for _ = 1, len do
                    pullTypeahead()
                end
            else
                local saveProps = inputProperties
                inputProperties = {}
                for _ = 1, len do
                    pullTypeahead()
                end
                local squashedUpdate = inputProperties
                inputProperties = saveProps
                insertTypeahead(dst[1], {update = squashedUpdate, index = 1})
                for i = 2, #dst do
                    insertTypeahead(dst[i], {index = i})
                end
                if not entry.remap then
                    noremapFor = #dst
                end
            end
        else
            noremapFor = 1
        end
    end
end

local function pullCount()  -- Returns string
    local ch = peekTypeaheadWRMP(1)
    while ch == "<C-S-v>" do
        pullTypeahead()
        expandPaste()
        ch = peekTypeaheadWRMP()
    end
    if ch:find("[^1-9]") then
        return ""
    end
    pullTypeahead()
    local builder = {ch}
    while true do
        ch = peekTypeaheadWRMP(1)
        while ch == "<C-S-v>" do
            pullTypeahead()
            expandPaste()
            ch = peekTypeaheadWRMP()
        end
        if ch:find("%D") then
            return table.concat(builder)
        end
        pullTypeahead()
        table.insert(builder, ch)
    end
end

local function pullCommand(input, numeric, len)
    if input == nil then
        input = ''
    end
    local x,y = 1, hig
    local oldModeMsg = modeMsg
    local prevMode = currentMode
    currentMode = "c"

    local backspace = false
    local finish = false
  
    repeat
        setcolors(colors.black, colors.white)
        setpos(x,y)
        write(input)
        if backspace then
            write("  ")
            resetSize()
            setpos(x - 1, y)
            if #input < 1 then
                finish = true
                insertTypeahead("bs", {index = 1})  -- Insert fake event to consume
            end
        end
        if #input > 0 then
            setpos(x + #input, y)
            setcolors(colors.lightGray, colors.white)
            write(" ")
        end
  
        modeMsg = input
        local key = pullTypeaheadWRMP()
        -- terminal cursor position is undefined after typeahead access
        y = hig
        setpos(x + #input, y)
  
        if isCharacterKey(key) then
            local p1 = getSelfInsert(key)
            local send = true
            if #input < 1 then
                setpos(1, 1)
                setcolors(colors.black, colors.white)
                write(" ")
            end
            if numeric and tonumber(p1) == nil then
                send = false
            end
            if len ~= nil then
                if (#input < len) and send then
                    input = input .. p1
                end
            else
                if send then
                    input = input .. p1
                end
            end
        elseif not finish then
            if key == "bs" then
                input = input:sub(1, #input - 1)
                backspace = true
            elseif key == "C-S-v" then
                expandPaste()
            end
        end
    until (key == "cr") or (finish == true)
    modeMsg = oldModeMsg
    currentMode = prevMode
    return input
end

local function pullTextObject(opts)
    local prevMode = currentMode
    currentMode = "o"
    opts = opts and itertools.collect(pairs(opts)) or {wantX = oldx}
    opts.x = opts.x or currCursorX + currXOffset
    opts.y = opts.y or currCursorY + currFileOffset
    opts.initialX = opts.initialX or opts.x
    opts.initialY = opts.initialY or opts.y
    local prio = {textObject = 2, motion = 1, max = 2}
    local cons = Trie.Consumer.new{
        n = prio.max,
        [prio.textObject] = textObjectsTrie,
        [prio.motion] = motionsTrie,
    }
    local countMultiplier = repeatCount1
    local countStr = pullCount()
    if #countStr > 0 then
        repeatCount0 = tonumber(countStr) * countMultiplier
        repeatCount1 = repeatCount0
    end
    local i = 0
    while true do
        i = i + 1
        local key
        if i == 1 then
            key = peekTypeaheadWRMP(i)
        else
            key = peekTypeahead(i)
        end
        if key == "C-c" then
            -- Clear typeahead
            for _ = 1, i do
                pullTypeahead()
            end
            cons = nil
            break
        end
        if not cons:next(key) then
            break
        end
        if not cons:hasNext() then
            break
        end
    end
    if cons ~= nil then
        local len, entry, kind = cons:getDeepest()
        if len > 0 then
            for _ = 1, len do
                pullTypeahead()
            end
            if kind == prio.textObject or kind == prio.motion then
                if entry[2] then
                    itertools.update(opts, entry[2])
                end
                opts = entry[1](opts) or opts
            end
        else
            -- Drop one key
            pullTypeahead()
            opts = nil
        end
    else
        opts = nil  -- no text object returned => operator should terminate
    end
    currentMode = prevMode
    return opts
end

-- Helper text objects
local function textObjectLine(opts)
    opts = opts and itertools.collect(pairs(opts)) or {wantX = oldx}
    opts.x = opts.x or currCursorX + currXOffset
    opts.y = opts.y or currCursorY + currFileOffset
    opts.initialX = opts.initialX or opts.x
    opts.initialY = opts.initialY or opts.y

    opts.linewise = true
    opts.y = opts.y + repeatCount1 - 1
    if opts.y > #filelines then
        opts.y = #filelines
    end
    return opts
end

local function textObjectEOL(opts)
    opts = opts and itertools.collect(pairs(opts)) or {wantX = oldx}
    opts.x = opts.x or currCursorX + currXOffset
    opts.y = opts.y or currCursorY + currFileOffset
    opts.initialX = opts.initialX or opts.x
    opts.initialY = opts.initialY or opts.y

    opts.y = opts.y + repeatCount1 - 1
    if opts.y > #filelines then
        opts.y = #filelines
    end
    opts.wantX = 999999999
    opts.x = #filelines[opts.y]
    return opts
end

local function textObjectSOL(opts)
    opts = opts and itertools.collect(pairs(opts)) or {wantX = oldx}
    opts.x = opts.x or currCursorX + currXOffset
    opts.y = opts.y or currCursorY + currFileOffset
    opts.initialX = opts.initialX or opts.x
    opts.initialY = opts.initialY or opts.y

    opts.wantX = nil
    local line = filelines[opts.y]
    opts.x = line:find("[^ \x09]") or #line
    if opts.x < 1 then
        opts.x = 1
    end
    return opts
end

local function clearScreenLine(line)
    setcolors(colors.black, colors.white)
    setpos(1, line)
    for i=1,wid,1 do
        write(" ")
    end
end

local function err(message)
    clearScreenLine(hig)
    setpos(1, hig)
    setcolors(colors.red, colors.white)
    write(message)
end

local function sendMsg(message)
    clearScreenLine(hig)
    setpos(1, hig)
    setcolors(colors.black, colors.white)
    write(message)
end

local function setModeMsg(msg)
    if msg and #msg > 0 then
        modeMsg = msg
        sendMsg(msg)
    else
        modeMsg = nil
        sendMsg(" ")
    end
end

local function getMLCSetCache()
    local mlc = fileContents[currfile]["Multi-line comments"]
    if not mlc._setCache then
        local cache = {}
        for i = 1, 3 do
            cache[i] = tab.itemIndices(mlc[i])
        end
        mlc._setCache = cache
    end
    return mlc._setCache
end

local function drawFileLine(i, synt)
    setpos(1, i - currFileOffset)
    if filelines then
        local lineVisualBeg = 0
        local lineVisualEd = 0
        if filelines[i] ~= nil then
            if visualSelectionRendered and visualModeState then
                local begX, begY, edX, edY = visualModeState.initialX, visualModeState.initialY, visualModeState.x, visualModeState.y
                if begX and begY and edX and edY then
                    if edY < begY or edY == begY and edX < begX then
                        begX, edX = edX, begX
                        begY, edY = edY, begY
                    end
                end
                if visualModeState.linewise then
                    if i >= begY and i <= edY then
                        lineVisualBeg = 1
                        lineVisualEd = #filelines[i]
                    end
                else
                    if i >= begY and i <= edY then
                        lineVisualBeg = 1
                        lineVisualEd = #filelines[i]
                    end
                    if i == begY then
                        lineVisualBeg = begX
                    end
                    if i == edY then
                        lineVisualEd = edX
                    end
                end
            end
            setcolors(colors.black, colors.white)
            if fileContents[currfile] then
                if synt then
                    local wordsOfLine = str.split(filelines[i], " ")
                    setpos(1 - currXOffset + lineoffset, i - currFileOffset)
                    local wordBeg = 1
                    local wordEd = -1
                    for j=1,#wordsOfLine,1 do
                        wordBeg = wordEd + 2
                        wordEd = wordBeg + #wordsOfLine[j] - 1
                        local hlBg, hlFg = colors.black, colors.white
                        if synt.keywordSets.todo[wordsOfLine[j]] then
                            hlBg, hlFg = colors.yellow, colors.blue
                        elseif synt.keywordSets.statement[wordsOfLine[j]] then
                            hlBg, hlFg = colors.black, colors.lightBlue
                        elseif synt.keywordSets.preproc[wordsOfLine[j]] then
                            hlBg, hlFg = colors.black, colors.purple
                        end
                        if lineVisualEd < lineVisualBeg or wordBeg > lineVisualEd or wordEd < lineVisualBeg then
                            setcolors(hlBg, hlFg)
                            write(wordsOfLine[j])
                        elseif wordBeg >= lineVisualBeg and wordEd <= lineVisualEd then
                            setcolors(colors.gray, hlFg)
                            write(wordsOfLine[j])
                        else
                            local wordVisualBeg = lineVisualBeg - wordBeg + 1
                            local wordVisualEd = lineVisualEd - wordBeg + 1
                            if wordVisualBeg < 1 then
                                wordVisualBeg = 1
                            end
                            if wordVisualEd < 1 then
                                wordVisualEd = 0
                            end
                            setcolors(hlBg, hlFg)
                            write(string.sub(wordsOfLine[j], 1, wordVisualBeg - 1))
                            setcolors(colors.gray, hlFg)
                            write(string.sub(wordsOfLine[j], wordVisualBeg, wordVisualEd))
                            setcolors(hlBg, hlFg)
                            write(string.sub(wordsOfLine[j], wordVisualEd + 1, #wordsOfLine[j]))
                        end
                        if j ~= #wordsOfLine then
                            if wordEd + 1 > lineVisualEd or wordEd + 1 < lineVisualBeg then
                                setcolors(colors.black, colors.white)
                            else
                                setcolors(colors.gray, colors.white)
                            end
                            write(" ")
                        end
                    end
                    --another loop for drawing strings
                    setpos(1 - currXOffset + lineoffset, i - currFileOffset)
                    local quotationmarks = str.indicesOfLetter(filelines[i], synt[3])
                    local quoteSet = tab.itemIndices(quotationmarks)
                    local inquotes = false
                    local justset = false
                    local quotepoints = {}
                    local hlBg, hlFg = colors.black, colors.red
                    setcolors(hlBg, hlFg)
                    for j=1,#filelines[i],1 do
                        if j == lineVisualBeg then
                            setcolors(colors.gray, hlFg)
                        end
                        if j == lineVisualEd + 1 then
                            setcolors(hlBg, hlFg)
                        end
                        local writechar = not ((1 - currXOffset - lineoffset + j - 1 < 1) or (1 - currXOffset + lineoffset + j - 1 > wid))
                        if writechar then
                            setpos(1 - currXOffset + lineoffset + j - 1, i - currFileOffset)
                        end
                        if quoteSet[j] then
                            if not inquotes then
                                if j < quotationmarks[#quotationmarks] then
                                    inquotes = true
                                    justset = true
                                end
                            end
                        end
                        if inquotes then
                            if writechar then
                                write(string.sub(filelines[i], j, j))
                            end
                            table.insert(quotepoints, #quotepoints, j - 2) --Don't know why I need to subtract 2 but heck it works
                        end
                        if quoteSet[j] and not justset then
                            if inquotes then
                                inquotes = false
                            end
                        end
                        justset = false
                    end
                    local commentstart = 0
                    commentstart = str.find(filelines[i], synt[4], quotepoints)
                    if commentstart and commentstart ~= false then
                        setpos(1 - currXOffset + lineoffset + commentstart - 1, i - currFileOffset)
                        local commentText = string.sub(filelines[i], commentstart, #filelines[i])
                        setcolors(colors.black, colors.green)
                        if lineVisualBeg > 0 and lineVisualEd > 0 and lineVisualBeg <= lineVisualEd then
                            local commentVisualBeg = lineVisualBeg - commentstart + 1
                            local commentVisualEd = lineVisualEd - commentstart + 1
                            if commentVisualBeg < 1 then
                                commentVisualBeg = 1
                            end
                            if commentVisualEd < 1 then
                                commentVisualEd = 0
                            end
                            setcolors(colors.black, colors.green)
                            write(string.sub(commentText, 1, commentVisualBeg - 1))
                            setcolors(colors.gray, colors.green)
                            write(string.sub(commentText, commentVisualBeg, commentVisualEd))
                            setcolors(colors.black, colors.green)
                            write(string.sub(commentText, commentVisualEd + 1, #commentText))
                        else
                            write(commentText)
                        end
                    end
                    commentstart = str.find(filelines[i], synt[7][2])
                    if not commentstart then
                        commentstart = 0
                    end
                    if not lowspec then
                        if getMLCSetCache()[2][i] then
                            setpos(1 - currXOffset + lineoffset, i - currFileOffset)
                            setcolors(colors.black, colors.green)
                            if lineVisualBeg > 0 and lineVisualEd > 0 and lineVisualBeg <= lineVisualEd then
                                write(string.sub(filelines[i], 1, lineVisualBeg - 1))
                                setcolors(colors.gray, colors.green)
                                write(string.sub(filelines[i], lineVisualBeg, lineVisualEd))
                                setcolors(colors.black, colors.green)
                                write(string.sub(filelines[i], lineVisualEd + 1, #filelines[i]))
                            else
                                write(string.sub(filelines[i], 1, #filelines[i]))
                            end
                        elseif getMLCSetCache()[3][i] then
                            setpos(1 - currXOffset + lineoffset, i - currFileOffset)
                            local commentText = string.sub(filelines[i], 1, commentstart + 1)
                            setcolors(colors.black, colors.green)
                            if lineVisualBeg > 0 and lineVisualEd > 0 and lineVisualBeg <= lineVisualEd then
                                write(string.sub(commentText, 1, lineVisualBeg - 1))
                                setcolors(colors.gray, colors.green)
                                write(string.sub(commentText, lineVisualBeg, lineVisualEd))
                                setcolors(colors.black, colors.green)
                                write(string.sub(commentText, lineVisualEd + 1, #commentText))
                            else
                                write(string.sub(commentText, 1, #commentText))
                            end
                        end
                    end
                else
                    setpos(1 - currXOffset + lineoffset, i - currFileOffset)
                    if lineVisualBeg > 0 and lineVisualEd > 0 and lineVisualBeg <= lineVisualEd then
                        setcolors(colors.black, colors.white)
                        write(string.sub(filelines[i], 1, lineVisualBeg - 1))
                        setcolors(colors.gray, colors.white)
                        write(string.sub(filelines[i], lineVisualBeg, lineVisualEd))
                        setcolors(colors.black, colors.white)
                        write(string.sub(filelines[i], lineVisualEd + 1, #filelines[i]))
                    else
                        write(string.sub(filelines[i], 1, #filelines[i]))
                    end
                end
            end
        else
            setcolors(colors.black, colors.purple)
            write("~")
        end
    end
end

local function drawFile(forcedredraw)
    motd = false
    local synt = nil
    if fileContents[currfile] and fileContents[currfile]["filetype"] and syntaxhighlighting and filetypearr[fileContents[currfile]["filetype"]] then
        synt = filetypearr[fileContents[currfile]["filetype"]].syntax()
        if synt then
            synt.keywordSets = {
                todo = tab.itemIndices(synt[1]),
                statement = tab.itemIndices(synt[2][1]),
                preproc = tab.itemIndices(synt[2][2]),
            }
        end
    end
    if currXOffset ~= oldXOffset or currFileOffset ~= oldFileOffset or forcedredraw then
        for i=1,hig-1,1 do
            clearScreenLine(i)
        end
        oldXOffset = currXOffset
        oldFileOffset = currFileOffset
        for i=currFileOffset,(hig - 1) + currFileOffset,1 do
            drawFileLine(i, synt)
        end
    else
        --only draw 3 lines
        for i=currCursorY + currFileOffset - 1, currCursorY + currFileOffset + 2, 1 do
            if i - currFileOffset < hig then
                clearScreenLine(i - currFileOffset)
                setpos(1, i - currFileOffset)
                drawFileLine(i, synt)
            end
        end
    end
    -- Draw the cursor
    local tmp
    if filelines then
        if filelines[currCursorY + currFileOffset] ~= nil then
            tmp = string.sub(filelines[currCursorY + currFileOffset], currCursorX + currXOffset, currCursorX + currXOffset)
        end
    end
    if filelines then
        setpos(currCursorX + lineoffset, currCursorY)
    else
        setpos(currCursorX, currCursorY)
    end
    setcolors(colors.lightGray, colors.white)
    if tmp ~= nil and tmp ~= "" then
        write(tmp)
    else
        write(" ")
    end
    if linenumbers then
        setcolors(colors.black, colors.yellow)
        for i=currFileOffset,(hig-1)+currFileOffset,1 do
            setpos(1, i - currFileOffset)
            if i < 1000 then
                write(string.rep(" ", 3 - #tostring(i)))
            end
            if i < 10000 then
                if i <= #filelines then
                    write(i)
                end
            else
                if i <= #filelines then
                    write("10k+")
                end
            end
        end
    end
end

local function cursorIntoFile()
    if currCursorY + currFileOffset > #filelines then
        currCursorY = #filelines - currFileOffset
    end
    if currCursorY + currFileOffset < 1 then
        currCursorY = 1 - currFileOffset
    end
    local line = filelines[currCursorY + currFileOffset]
    if line and #line < currCursorX + currXOffset then
        currCursorX = #line - currXOffset
    end
    if currCursorX + currXOffset < 1 then
        currCursorX = 1 - currXOffset
    end
end

local function scrollToCursor()
    local forcedredraw = false
    if currCursorY > hig - 1 then
        local delta = hig - 1 - currCursorY
        currCursorY = currCursorY + delta
        currFileOffset = currFileOffset - delta
    end
    if currCursorY < 1 then
        currFileOffset = currFileOffset + currCursorY - 1
        currCursorY = 1
    end
    if currCursorX + lineoffset > wid then
        local delta = wid - currCursorX - lineoffset
        currCursorX = currCursorX + delta
        currXOffset = currXOffset - delta
        forcedredraw = true
    end
    if currCursorX < 1 then
        currXOffset = currXOffset + currCursorX - 1
        currCursorX = 1
        forcedredraw = true
    end
    return forcedredraw
end

local function moveCursorLeft()
    lastSearchPos = nil
    lastSearchLine = nil
    if currCursorX + currXOffset ~= 1 then
        currCursorX = currCursorX - 1
        if currCursorX < 1 then
            currCursorX = currCursorX + 1
            currXOffset = currXOffset - 1
            drawFile(true)
        else
            drawFile()
        end
    end
    oldx = nil
end

local function moveCursorRight(endPad)
    lastSearchPos = nil
    lastSearchLine = nil
    if endPad == nil then
        endPad = 0
    end
    if filelines[currCursorY + currFileOffset] ~= nil then
        if currCursorX + currXOffset < #(filelines[currCursorY + currFileOffset]) + 1 - endPad then
            currCursorX = currCursorX + 1
            if currCursorX + lineoffset > wid then
                currCursorX = currCursorX - 1
                currXOffset = currXOffset + 1
                drawFile(true)
            else
                drawFile()
            end
        end
    end
    oldx = nil
end

local function moveCursorUp(ignoreX)
    lastSearchPos = nil
    lastSearchLine = nil
    if oldx ~= nil and not ignoreX then
        currCursorX = oldx - currXOffset
    else
        oldx = currCursorX + currXOffset
    end
    if currCursorY + currFileOffset ~= 1 then
        currCursorY = currCursorY - 1
        if currCursorX + currXOffset > #(filelines[currCursorY + currFileOffset]) + 1 then
            if filelines[currCursorY + currFileOffset] ~= "" then
                currCursorX = #(filelines[currCursorY + currFileOffset]) + 1 - currXOffset
            else
                currCursorX = 1
                currXOffset = 0
            end
        end
        if currCursorX < 1 then
            while currCursorX < 1 do
                currXOffset = currXOffset - 1
                currCursorX = currCursorX + 1
            end
        elseif currCursorX + lineoffset > wid then
            while currCursorX + lineoffset > wid do
                currXOffset = currXOffset + 1
                currCursorX = currCursorX - 1
            end
        end
        while currCursorY < 1 do
            currFileOffset = currFileOffset - 1
            currCursorY = currCursorY + 1
        end
        while currFileOffset < 0 do
            currFileOffset = currFileOffset + 1
        end
        drawFile()
    end
end

local function moveCursorDown()
    lastSearchPos = nil
    lastSearchLine = nil
    if oldx ~= nil then
        currCursorX = oldx - currXOffset
    else
        oldx = currCursorX + currXOffset
    end
    if currCursorY + currFileOffset < #filelines then
        currCursorY = currCursorY + 1
        if currCursorX + currXOffset > #(filelines[currCursorY + currFileOffset]) + 1 then
            if filelines[currCursorY + currFileOffset] ~= "" then
                currCursorX = #(filelines[currCursorY + currFileOffset]) + 1 - currXOffset
            else
                currCursorX = 1
                currXOffset = 0
            end
        end
        if currCursorX < 1 then
            while currCursorX < 1 do
                currXOffset = currXOffset - 1
                currCursorX = currCursorX + 1
            end
        elseif currCursorX + lineoffset > wid then
            while currCursorX + lineoffset > wid do
                currXOffset = currXOffset + 1
                currCursorX = currCursorX - 1
            end
        end
        while currCursorY > hig - 1 do
            currFileOffset = currFileOffset + 1
            currCursorY = currCursorY - 1
        end
        drawFile()
    end
end

local function scrollWindowY(amount, currSOL)
    resetLastSearch()
    if not currSOL then
        if oldx ~= nil then
            currCursorX = oldx - currXOffset
        else
            oldx = currCursorX + currXOffset
        end
    end
    if amount == 0 then
        return
    end
    currFileOffset = currFileOffset + amount
    if amount < 0 then
        if currFileOffset < 0 then
            currCursorY = currCursorY + currFileOffset
            currFileOffset = 0
            if currCursorY < 1 then
                currCursorY = 1
            end
        end
    else
        if currCursorY + currFileOffset > #filelines then
            currCursorY = #filelines - currFileOffset
            if currCursorY < 1 then
                currFileOffset = currFileOffset + currCursorY - 1
                currCursorY = 1
                if currFileOffset < 0 then
                    currFileOffset = 0
                end
            end
        end
    end
    local line = filelines[currCursorY + currFileOffset]
    if currSOL then
        currXOffset = 0
        currCursorX = 1
        if line then
            currCursorX = line:find("[^ \x09]") or #line
        end
        if currCursorX < 1 then
            currCursorX = 1
        end
        if currCursorX + lineoffset > wid then
            local delta = wid - currCursorX - lineoffset
            currCursorX = currCursorX + delta
            currXOffset = currXOffset - delta
        end
    else
        if line and #line < currCursorX + currXOffset then
            currCursorX = #line - currXOffset
            if currCursorX < 1 then
                currXOffset = currXOffset + currCursorX - 1
                currCursorX = 1
                if currXOffset < 0 then
                    currXOffset = 0
                end
            end
        end
    end
    drawFile(true)
end

local function performMotion(opts, cb)
    resetLastSearch()
    opts = opts and itertools.collect(pairs(opts)) or {}
    opts.wantX = oldx
    opts.x = currCursorX + currXOffset
    opts.y = currCursorY + currFileOffset
    opts = cb(opts) or opts
    local dy = opts.y - currFileOffset - currCursorY
    oldx = opts.wantX or nil
    currCursorX = opts.x - currXOffset
    currCursorY = opts.y - currFileOffset
    cursorIntoFile()
    drawFile(scrollToCursor() or dy > 1 or dy < -1)
end

--Recalculate where multi-line comments are, based on position in file
local function recalcMLCs(force, offsetby)
    if not fileContents[currfile] then
        return
    end
    if not fileContents[currfile]["Multi-line comments"] then
        fileContents[currfile]["Multi-line comments"] = {{}, {}, {}}
    end
    if not lowspec then
        fileContents[currfile]["Multi-line comments"]._setCache = nil
        local synt
        if fileContents[currfile]["filetype"] then
            if fs.exists("/vim/syntax/"..fileContents[currfile]["filetype"]..".lua")then
                local tmp = require("/vim/syntax/"..fileContents[currfile]["filetype"])
                synt = tmp.syntax()
            end
        end
        if synt then
            if offsetby then
                --move all multi-line comments after the current cursor Y by offsetby
                for i=1,#fileContents[currfile]["Multi-line comments"][1],1 do
                    if fileContents[currfile]["Multi-line comments"][1][i] > currCursorY + currFileOffset + offsetby[1] then
                        fileContents[currfile]["Multi-line comments"][1][i] = fileContents[currfile]["Multi-line comments"][1][i] + offsetby[2]
                    end
                end
                for i=1,#fileContents[currfile]["Multi-line comments"][2],1 do
                    if fileContents[currfile]["Multi-line comments"][2][i] > currCursorY + currFileOffset + offsetby[1] then
                        fileContents[currfile]["Multi-line comments"][2][i] = fileContents[currfile]["Multi-line comments"][2][i] + offsetby[2]
                    end
                end
                for i=1,#fileContents[currfile]["Multi-line comments"][3],1 do
                    if fileContents[currfile]["Multi-line comments"][3][i] > currCursorY + currFileOffset + offsetby[1] then
                        fileContents[currfile]["Multi-line comments"][3][i] = fileContents[currfile]["Multi-line comments"][3][i] + offsetby[2]
                    end
                end
                if getMLCSetCache()[2][currCursorY + currFileOffset - 1] then
                    --if the cursor - 1 is on a multi-line comment (type 2), then check if the current line contains the end of the comment.
                    --if it does, add it as type 3. If not, add it as type 2.
                    if str.find(fileContents[currfile][currCursorY + currFileOffset], "]]") then
                        table.insert(fileContents[currfile]["Multi-line comments"][3], currCursorY + currFileOffset)
                    else
                        table.insert(fileContents[currfile]["Multi-line comments"][2], currCursorY + currFileOffset)
                    end
                end
            else
                if ((getMLCSetCache()[1][currCursorY + currFileOffset] and not str.find(filelines[currCursorY + currFileOffset], synt[7][1])) or (not getMLCSetCache()[1][currCursorY + currFileOffset] and str.find(filelines[currCursorY + currFileOffset], synt[7][1])) or (getMLCSetCache()[3][currCursorY + currFileOffset] and not str.find(filelines[currCursorY + currFileOffset], synt[7][2])) or (not getMLCSetCache()[3][currCursorY + currFileOffset] and str.find(filelines[currCursorY + currFileOffset], synt[7][2])) or force) and syntaxhighlighting then
                    local multilinesInFile = {{}, {}, {}} --beginning quote points, regular quote points, end quote points
                    local quotepoints = {}
                    local justset = false
                    for j=1,#fileContents[currfile],1 do
                        local quotationmarks = str.indicesOfLetter(fileContents[currfile][j], synt[3])
                        local quoteSet = tab.itemIndices(quotationmarks)
                        local inquotes = false
                        justset = false
                        for k=1,#fileContents[currfile][j],1 do
                            if quoteSet[k] then
                                if not inquotes then
                                    if k < quotationmarks[#quotationmarks] then
                                        inquotes = true
                                        justset = true
                                    end
                                end
                            end
                            if inquotes then
                                table.insert(quotepoints, #quotepoints, k - 2)
                            end
                            if quoteSet[k] and not justset then
                                if inquotes then
                                    inquotes = false
                                end
                            end
                            justset = false
                        end
                    end
                    local inmulti = false
                    justset = false
                    for j=1,#fileContents[currfile],1 do
                        if str.find(fileContents[currfile][j], synt[7][1], quotepoints) and not inmulti then
                            inmulti = true
                            justset = true
                            table.insert(multilinesInFile[1], #multilinesInFile[1] + 1, j)
                        end
                        if inmulti and not (str.find(fileContents[currfile][j], synt[7][2])) and not justset then
                            table.insert(multilinesInFile[2], #multilinesInFile[2] + 1, j)
                        end
                        if str.find(fileContents[currfile][j], synt[7][2]) then
                            if inmulti then
                                inmulti = false
                                table.insert(multilinesInFile[3], #multilinesInFile[3] + 1, j)
                            end
                        end
                        justset = false
                    end
                    fileContents[currfile]["Multi-line comments"] = multilinesInFile
                    return true
                else
                    return false
                end
            end
        end
    else
        return false
    end
end

local function redrawTerm()
    clearScreenLine(hig)
    if motd then
        clear()
        for i=currFileOffset,(hig - 1) + currFileOffset,1 do
            setpos(1, i - currFileOffset)
            setcolors(colors.black, colors.purple)
            write("~")
        end
        setcolors(colors.black, colors.white)
        setpos((wid / 2) - (33 / 2), (hig / 2) - 3)
        write("CCVIM - ComputerCraft Vi Improved")
        setpos((wid / 2) - (#("version ".. version) / 2), (hig / 2) - 1)
        write("version "..version)
        setpos((wid / 2) - (13 / 2), (hig / 2))
        write("By Minater247")
        if wid > 53 then
            setpos((wid / 2) - (46 / 2), (hig / 2) + 1)
            write("CCVIM is open source and freely distributable.")
            setpos((wid / 2) - (28 / 2), (hig / 2) + 4)
        else
            setpos((wid / 2) - (28 / 2), (hig / 2) + 3)
        end
        write("Type :q")
        setcolors(colors.black, colors.lightBlue)
        write("<Enter>       ")
        setcolors(colors.black, colors.white)
        write("to exit")
    else
        drawFile(true)
    end
    while currCursorX + lineoffset > wid do
        currCursorX = currCursorX - 1
        currXOffset = currXOffset + 1
    end
    while currCursorX < 1 do
        currCursorX = currCursorX + 1
        currXOffset = currXOffset - 1
    end
    while currCursorY > hig - 1 do
        currCursorY = currCursorY - 1
        currFileOffset = currFileOffset + 1
    end
    while currCursorY < 1 do
        currCursorY = currCursorY + 1
        currFileOffset = currFileOffset - 1
    end
end

-- declared above
function handleNonInputEvent(e, s, v2, v3)
    if e == "term_resize" then
        resetSize()
        redrawTerm()
        if modeMsg ~= nil then
            sendMsg(modeMsg)
        end
    elseif useTmKeyboards and e:find("^tm_keyboard_") then
        local innerEvent = e:match("^tm_keyboard_(.+)$")
        local outerActiveModifiers = activeModifiers
        local outerPrefixedModifiers = prefixedModifiers
        if not keyboards[s] then
            keyboards[s] = {activeModifiers = {}, prefixedModifiers = {}}
        end
        activeModifiers = keyboards[s].activeModifiers
        prefixedModifiers = keyboards[s].prefixedModifiers
        handleOsEvent(innerEvent, v2, v3, nil)
        activeModifiers = outerActiveModifiers
        prefixedModifiers = outerPrefixedModifiers
    end
end

local normalModeSingle
local function insertMode()
    drawFile(true)
    setModeMsg("-- INSERT --")
    local prevMode = currentMode
    currentMode = "i"
    local key
    while key ~= "tab" do
        key = pullTypeaheadWRMP()
        if not isCharacterKey(key) and key ~= "C-v" then
            if key == "left" then
                moveCursorLeft()
            elseif key == "right" then
                moveCursorRight()
            elseif key == "up" then
                moveCursorUp()
            elseif key == "down" then
                moveCursorDown()
            elseif key == "C-S-v" then
                expandPaste(true)
            elseif key == "C-o" then
                setModeMsg("-- (insert) --")
                normalModeSingle()
                setModeMsg("-- INSERT --")
            elseif key == "bs" then
                if filelines[currCursorY + currFileOffset] ~= "" and filelines[currCursorY + currFileOffset] ~= nil and currCursorX > 1 then
                    filelines[currCursorY + currFileOffset] = string.sub(filelines[currCursorY + currFileOffset], 1, currCursorX + currXOffset - 2) .. string.sub(filelines[currCursorY + currFileOffset], currCursorX + currXOffset, #(filelines[currCursorY + currFileOffset]))
                    moveCursorLeft()
                    local redrawhere = recalcMLCs()
                    fileContents[currfile]["unsavedchanges"] = true
                    drawFile(redrawhere)
                else
                    if currCursorX + currXOffset < 2 then
                        if currCursorY + currFileOffset > 1 then
                            if #filelines > 1 then
                                currCursorX = #(filelines[currCursorY + currFileOffset - 1]) + 1
                                filelines[currCursorY + currFileOffset - 1] = filelines[currCursorY + currFileOffset - 1] .. filelines[currCursorY + currFileOffset]
                                table.remove(filelines, currCursorY + currFileOffset)
                                moveCursorUp(true)
                                if currCursorX + lineoffset > wid then
                                    while currCursorX + lineoffset > wid do
                                        currXOffset = currXOffset + 1
                                        currCursorX = currCursorX - 1
                                    end
                                end
                                recalcMLCs()
                                drawFile(true)
                                fileContents[currfile]["unsavedchanges"] = true
                            end
                        end
                    else
                        filelines[currCursorY + currFileOffset] = string.sub(filelines[currCursorY + currFileOffset], 1, currCursorX + currXOffset - 2) .. string.sub(filelines[currCursorY + currFileOffset], currCursorX + currXOffset, #(filelines[currCursorY + currFileOffset]))
                        currXOffset = currXOffset - math.floor(wid / 2)
                        currCursorX = currCursorX + math.floor(wid / 2) - 1
                        if currXOffset < 0 then
                            currCursorX = currXOffset + currCursorX
                            currXOffset = 0
                        end
                        local redrawhere = recalcMLCs()
                        drawFile(redrawhere)
                        fileContents[currfile]["unsavedchanges"] = true
                        lastSearchPos = nil
                        lastSearchLine = nil
                    end
                end
            elseif key == "cr" then
                lastSearchPos = nil
                lastSearchLine = nil
                if filelines[currCursorY + currFileOffset] ~= nil then
                    local indentedamount = 0
                    if autoindent then
                        --check if current line is indented, if so, indent the new line
                        for i=1,#(filelines[currCursorY + currFileOffset]),1 do
                            if string.sub(filelines[currCursorY + currFileOffset], i, i) == " " then
                                indentedamount = indentedamount + 1
                            else
                                break
                            end
                        end
                    end
                    table.insert(filelines, currCursorY + currFileOffset + 1, string.rep(" ", indentedamount) .. string.sub(filelines[currCursorY + currFileOffset], currCursorX + currXOffset, #(filelines[currCursorY + currFileOffset])))
                    filelines[currCursorY + currFileOffset] = string.sub(filelines[currCursorY + currFileOffset], 1, currCursorX + currXOffset - 1)
                    currCursorY = currCursorY + 1
                    while currCursorY > hig - 1 do
                        currFileOffset = currFileOffset + 1
                        currCursorY = currCursorY - 1
                    end
                    currCursorX = 1
                    currXOffset = 0
                    for i=1,indentedamount,1 do
                        currCursorX = currCursorX + 1
                        while currCursorX + lineoffset > wid do
                            currXOffset = currXOffset + 1
                            currCursorX = currCursorX - 1
                        end
                        if currXOffset < 0 then
                            currXOffset = 0
                        end
                    end
                    fileContents[currfile]["unsavedchanges"] = true
                else
                    table.insert(filelines, currCursorY + currFileOffset + 1, "")
                end
                recalcMLCs(false, {-1, 1}) --slow, but it works for now
                drawFile(true)
            end
        else
            lastSearchPos = nil
            lastSearchLine = nil
            if filelines[currCursorY + currFileOffset] == nil then
                filelines[currCursorY + currFileOffset] = ""
            end
            local ch
            if key == "C-v" then
                local rawKey = pullTypeahead()
                if rawKey == "x" then
                    local valid = true
                    local charCode = 0
                    for _ = 1, 2 do
                        local nibbleChar = pullTypeahead()
                        if not nibbleChar:find("^[0-9A-Fa-f]$") then
                            valid = false
                            break
                        end
                        local nibbleNum
                        if nibbleChar:find("[A-F]") then
                            nibbleNum = nibbleChar:byte() - ("A"):byte() + 10
                        elseif nibbleChar:find("[a-f]") then
                            nibbleNum = nibbleChar:byte() - ("a"):byte() + 10
                        else
                            nibbleNum = nibbleChar:byte() - ("0"):byte()
                        end
                        charCode = charCode * 16 + nibbleNum
                    end
                    if valid then
                        ch = string.char(charCode)
                    else
                        ch = ""
                    end
                else
                    ch = getSelfInsert(rawKey)
                end
            else
                ch = getSelfInsert(key)
            end
            if ch == "\n" then
                ch = ""
                insertTypeahead("cr", {index = 1})
            end
            filelines[currCursorY + currFileOffset] = string.sub(filelines[currCursorY + currFileOffset], 1, currCursorX + currXOffset - 1) .. ch ..string.sub(filelines[currCursorY + currFileOffset], currCursorX + currXOffset, #(filelines[currCursorY + currFileOffset]))
            currCursorX = currCursorX + #ch
            while currCursorX + lineoffset > wid do
                currCursorX = currCursorX - 1
                currXOffset = currXOffset + 1
            end
            local redrawhere = recalcMLCs()
            drawFile(redrawhere)
            if not fileContents[currfile] then
                fileContents[currfile] = {""}
            end
            fileContents[currfile]["unsavedchanges"] = true
        -- mouse_click was already translated to tab by the pullTypeahead
        end
    end
    setModeMsg(nil)
    currentMode = prevMode
end

registerVisualAction("<tab>", function()
    return true
end)

local function visualMode()
    drawFile(true)
    local prevMode = currentMode
    currentMode = "x"
    local visualModeRunning = true
    local prio = {visualAction = 3, textObject = 2, motion = 1, max = 3}
    local forcedredraw = true
    while visualModeRunning do
        visualModeState = visualModeState or {}
        visualModeState.x = visualModeState.x or currCursorX + currXOffset
        visualModeState.y = visualModeState.y or currCursorY + currFileOffset
        visualModeState.initialX = visualModeState.initialX or visualModeState.x
        visualModeState.initialY = visualModeState.initialY or visualModeState.y
        visualModeState.exclusive = false
        visualSelectionRendered = true
        currCursorX = visualModeState.x - currXOffset
        currCursorY = visualModeState.y - currFileOffset
        oldx = visualModeState.wantX
        scrollToCursor()
        drawFile(forcedredraw)
        if visualModeState.linewise then
            setModeMsg("-- VISUAL LINE --")
        else
            setModeMsg("-- VISUAL --")
        end
        local cons = Trie.Consumer.new{
            n = prio.max,
            [prio.visualAction] = visualActionsTrie,
            [prio.textObject] = textObjectsTrie,
            [prio.motion] = motionsTrie,
        }
        local countStr = pullCount()
        if #countStr > 0 then
            repeatCount0 = tonumber(countStr)
            repeatCount1 = repeatCount0
        else
            repeatCount0 = 0
            repeatCount1 = 1
        end
        local i = 0
        while true do
            i = i + 1
            local key
            if i == 1 then
                key = peekTypeaheadWRMP(i)
            else
                key = peekTypeahead(i)
            end
            if key == "C-c" then
                -- Clear typeahead
                for _ = 1, i do
                    pullTypeahead()
                end
                cons = nil
                visualModeRunning = false
                break
            end
            if not cons:next(key) then
                break
            end
            if not cons:hasNext() then
                break
            end
        end
        if cons ~= nil then
            local len, entry, kind = cons:getDeepest()
            if len > 0 then
                for _ = 1, len do
                    pullTypeahead()
                end
                local oldLinewise = visualModeState.linewise
                local oldInitialX = visualModeState.initialX
                local oldInitialY = visualModeState.initialY
                local oldY = visualModeState.y
                if kind == prio.visualAction then
                    if entry() then
                        visualModeRunning = false
                    end
                elseif kind == prio.textObject or kind == prio.motion then
                    if entry[2] then
                        itertools.update(visualModeState, entry[2])
                    end
                    visualModeState = entry[1](visualModeState) or visualModeState
                end
                visualModeState.exclusive = false
                currCursorX = visualModeState.initialX or visualModeState.x
                currCursorX = currCursorX - currXOffset
                currCursorY = visualModeState.initialY or visualModeState.y
                currCursorY = currCursorY - currFileOffset
                cursorIntoFile()
                visualModeState.initialX = currCursorX + currXOffset
                visualModeState.initialY = currCursorY + currFileOffset
                currCursorX = visualModeState.x
                currCursorX = currCursorX - currXOffset
                currCursorY = visualModeState.y
                currCursorY = currCursorY - currFileOffset
                cursorIntoFile()
                visualModeState.x = currCursorX + currXOffset
                visualModeState.y = currCursorY + currFileOffset
                forcedredraw = false
                if oldLinewise ~= visualModeState.linewise or oldInitialY ~= visualModeState.initialY then
                    forcedredraw = true
                elseif visualModeState.y - oldY > 1 or visualModeState.y - oldY < -1 then
                    forcedredraw = true
                elseif oldInitialX ~= visualModeState.initialX then
                    forcedredraw = true
                end
            else
                -- Drop one key
                pullTypeahead()
                opts = nil
            end
        else
            visualModeRunning = false
            break
        end
    end
    visualSelectionRendered = false
    drawFile(true)
    setModeMsg(nil)
    currentMode = prevMode
end

--Parse .vimrc file here
if fs.exists("/vim/.vimrc") then
    local vimrclines = fil.toArr("/vim/.vimrc")
    for i=1,#vimrclines,1 do
        if not (string.sub(vimrclines[i], 1, 1) == "\"") then --ignore commented lines
            local rctable = str.split(vimrclines[i], " ")
            if rctable[1] == "set" then
                if not string.find(rctable[2], "=") then
                    if rctable[2] == "mobile" then
                        mobile = true
                    elseif rctable[2] == "number" then
                        linenumbers = true
                        lineoffset = 4
                    elseif rctable[2] == "lowperformance" then
                        lowspec = true
                    elseif rctable[2] == "autoindent" then
                        autoindent = true
                    elseif rctable[2] == "ignorecase" or rctable[2] == "ic" then
                        ignorecase = true
                    end
                else
                    --set the things to values
                end
            elseif rctable[1] == "syntax" and rctable[2] == "on" then
                syntaxhighlighting = true
            elseif mappingCommands[rctable[1]] ~= nil then
                if rctable[2] and rctable[3] or not (#rctable > 3) then
                    local opts = mappingCommands[rctable[1]]
                    registerMapping(rctable[2], rctable[3], opts)
                else
                    print("Mapping requires 2 arguments.")
                    sendMsg("Press enter to continue...")
                    local _,k = os.pullEvent("key")
                    while k ~= keys.enter do
                        _,k = os.pullEvent("key")
                    end
                end
            elseif rctable[1] == "finish" then
                break
            elseif rctable[1] == "ignorehold" then
                local i = 1
                while i < #rctable do
                    i = i + 1
                    local keyCode = keys[rctable[i]]
                    if keyCode ~= nil then
                        ignoreHold[keyCode] = true
                    end
                end
            elseif rctable[1] ~= "" and rctable[1] ~= nil then
                error("Unrecognized vimrc command " .. rctable[1] .. ". Full vimscript is not yet supported.")
            end
        end
    end
end

local function pullChar()
    local _, tm = os.pullEvent("char")
    return _, tm
end

local function pullTypeaheadChar()
    local ch
    repeat
        local key = pullTypeaheadWRMP()
        if key == "C-S-v" then
            expandPaste()
        end
        ch = getSelfInsert(key)
    until #ch == 1
    return ch
end

local function pullTypeaheadCharMode(mode)
    local prevMode = currentMode
    currentMode = mode
    local ch = pullTypeaheadChar()
    currentMode = prevMode
    return ch
end

local oldyoff
local function drawDirInfo(dir, sortType, ypos, yoff, filesInDir, initialDraw)
    if initialDraw then
        setcolors(colors.black, colors.white)
        for i=1,hig-1,1 do
            clearScreenLine(i)
        end
        setpos(1, 1)
        write("\" ")
        for i=1,wid - 4,1 do
            write("=")
        end
        setpos(1, 2)
        write("\" CCFXP Directory Listing")
        for i=1,wid-25,1 do
            write(" ")
        end
        setpos(wid-#tostring(fileExplorerVer)-6, 2)
        write("ver. "..fileExplorerVer)
        setpos(1, 5)
        write("\"   Quick Help: -:go up dir  D:delete  R:rename  s:sort-by")
        for i=1,wid-#("\"   Quick Help: -:go up dir  D:delete  R:rename  s:sort-by"),1 do
            write(" ")
        end
    end
    for i=1,wid-#("\"   "..shell.resolve(dir)),1 do
        write(" ")
    end
    setpos(1, 3)
    write("\"   "..shell.resolve(dir))
    if fs.isDir(shell.resolve(dir)) then
        write("/")
    end
    clearScreenLine(4)
    setpos(1, 4)
    write("\"   Sorted by    ")
    write(sortType)
    for i=1,wid-#("\"   Sorted by    "..sortType),1 do
        write(" ")
    end
    setpos(1, 6)
    setcolors(colors.black, colors.white)
    write("\" ")
    for i=1,wid - 2,1 do
        write("=")
    end
    if oldyoff ~= yoff or initialDraw then
        for i=1+yoff,hig - 7 + yoff,1 do
            clearScreenLine(6+i - yoff)
            setpos(1, 6+i - yoff)
            if i - yoff == ypos then
                setcolors(colors.lightGray, colors.white)
            else
                setcolors(colors.black, colors.white)
            end
            if 6 + i - yoff < hig then
                if filesInDir[i] then
                    write(filesInDir[i])
                    if fs.isDir(dir .. "/" .. filesInDir[i]) then
                        write("/")
                    end
                else
                    setcolors(colors.black, colors.purple)
                    write("~")
                    setcolors(colors.black, colors.white)
                end
            end
        end
        setcolors(colors.black, colors.white)
        oldyoff = yoff
    else
        for i=-1,1,1 do
            setpos(1, 6 + ypos + i)
            if i == 0 then
                setcolors(colors.lightGray, colors.white)
            else
                setcolors(colors.black, colors.white)
            end
            if 6 + ypos + i > 6 and 6 + ypos + i < hig then
                if filesInDir[ypos + yoff + i] then
                    write(filesInDir[ypos + yoff + i])
                    if fs.isDir(dir .. "/" .. filesInDir[ypos + yoff + i]) then
                        write("/")
                    end
                else
                    setcolors(colors.black, colors.purple)
                    write("~")
                    setcolors(colors.black, colors.white)
                end
            end
        end
        setcolors(colors.black, colors.white)
    end
end

-- Directory opener.
-- Make sure the path is passed through fil.path() before coming to this function.
-- Display name can be passed to inputname, but is optional.
local function dirOpener(dir, inputname)
    local currSelection = dir.."/"
    if inputname then
        sendMsg("\"/"..shell.resolve(inputname).."/\" is a directory")
    else
        sendMsg("\"/"..shell.resolve(dir).."/\" is a direcotry")
    end
    local sortType = "name"
    local currDirY = 1
    local currDirOffset = 0
    local realFilesInDir = fs.list(currSelection)
    local filesInDir = {".."}
    local firstDraw = true
    for i=1,#realFilesInDir,1 do
        table.insert(filesInDir, #filesInDir + 1, realFilesInDir[i])
    end
    if fs.isDir(dir) then
        local stillInExplorer = true
        local redrawNext = false
        local dothide = false
        local reverseSort = false
        local e, k
        while stillInExplorer do
            local realFilesInDir = fs.list(currSelection)
            local filesInDir = {}
            if not (shell.resolve(currSelection) == "") then
                filesInDir = {".."}
            end
            for i=1,#realFilesInDir,1 do
                if dothide then
                    if not (realFilesInDir[i]:sub(1, 1) == ".") then
                        table.insert(filesInDir, #filesInDir + 1, realFilesInDir[i])
                    end
                else
                    table.insert(filesInDir, #filesInDir + 1, realFilesInDir[i])
                end
            end
            if sortType == "name" then
                table.sort(filesInDir, 
                    function (k1, k2)
                        if reverseSort then
                            if fs.isDir(currSelection .. "/" .. k1) and not fs.isDir(currSelection .. "/" .. k2) then
                                return false
                            elseif fs.isDir(currSelection .. "/" .. k1) and fs.isDir(currSelection .. "/" .. k2) then
                                return k1 > k2
                            elseif not fs.isDir(currSelection .. "/" .. k1) and fs.isDir(currSelection .. "/" .. k2) then
                                return true
                            else
                                return k1 > k2
                            end
                        else
                            if fs.isDir(currSelection .. "/" .. k1) and not fs.isDir(currSelection .. "/" .. k2) then
                                return true
                            elseif fs.isDir(currSelection .. "/" .. k1) and fs.isDir(currSelection .. "/" .. k2) then
                                return k1 < k2
                            elseif not fs.isDir(currSelection .. "/" .. k1) and fs.isDir(currSelection .. "/" .. k2) then
                                return false
                            else
                                return k1 < k2
                            end
                        end
                    end)
            elseif sortType == "extension" then
                table.sort(filesInDir, 
                    function (k1, k2)
                        if reverseSort then
                            if fs.isDir(currSelection .. "/" .. k1) and not fs.isDir(currSelection .. "/" .. k2) then
                                return false
                            elseif fs.isDir(currSelection .. "/" .. k1) and fs.isDir(currSelection .. "/" .. k2) then
                                return k1 > k2
                            elseif not fs.isDir(currSelection .. "/" .. k1) and fs.isDir(currSelection .. "/" .. k2) then
                                return true
                            else
                                if str.getFileExtension(k1) == str.getFileExtension(k2) then
                                    return k1 > k2
                                elseif str.getFileExtension(k1) == "" and str.getFileExtension(k2) ~= "" then
                                    return true
                                elseif str.getFileExtension(k1) ~= "" and str.getFileExtension(k2) == "" then
                                    return false
                                else
                                    return str.getFileExtension(k1) > str.getFileExtension(k2)
                                end
                            end
                        else
                            if fs.isDir(currSelection .. "/" .. k1) and not fs.isDir(currSelection .. "/" .. k2) then
                                return true
                            elseif fs.isDir(currSelection .. "/" .. k1) and fs.isDir(currSelection .. "/" .. k2) then
                                return k1 < k2
                            elseif not fs.isDir(currSelection .. "/" .. k1) and fs.isDir(currSelection .. "/" .. k2) then
                                return false
                            else
                                if str.getFileExtension(k1) == str.getFileExtension(k2) then
                                    return k1 < k2
                                elseif str.getFileExtension(k1) == "" and str.getFileExtension(k2) ~= "" then
                                    return false
                                elseif str.getFileExtension(k1) ~= "" and str.getFileExtension(k2) == "" then
                                    return true
                                else
                                    return str.getFileExtension(k1) < str.getFileExtension(k2)
                                end
                            end
                        end
                    end)  --this whole large table.sort function sorts out the directories first and the extensionless files last
            elseif sortType == "size" then
                table.sort(filesInDir,
                    function (k1, k2)
                        if reverseSort then
                            return fs.getSize(currSelection.."/"..k1) > fs.getSize(currSelection.."/"..k2)
                        else
                            return fs.getSize(currSelection.."/"..k1) < fs.getSize(currSelection.."/"..k2)
                        end
                    end)
            end
            if redrawNext then
                drawDirInfo(currSelection, sortType, currDirY, currDirOffset, filesInDir, true)
                redrawNext = false
            elseif e ~= "key_up" then
                drawDirInfo(currSelection, sortType, currDirY, currDirOffset, filesInDir, firstDraw)
            end
            e, k = os.pullEvent()
            if e == "char" then
                if k == "s" then
                    if sortType == "name" then
                        sortType = "size"
                    elseif sortType == "size" then
                        sortType = "extension"
                    elseif sortType == "extension" then
                        sortType = "name"
                    end
                    redrawNext = true
                elseif k == "d" then
                    sendMsg("Please give directory name: ")
                    local newdirname = read()
                    if newdirname then
                        if fs.isReadOnly(currSelection) then
                            err("Directory is read-only")
                        else
                            fs.makeDir(currSelection.."/"..newdirname)
                        end
                    end
                    redrawNext = true
                elseif k == "D" then
                    clearScreenLine(hig)
                    local sst = "Confirm deletion of directory<"..shell.resolve(currSelection.."/"..filesInDir[currDirY + currDirOffset]).."> [{y(es)},n(o),a(ll),q(uit)]"
                    if #sst > wid then
                        clearScreenLine(hig - 1)
                        setpos(1, hig-1)
                    else
                        setpos(1, hig)
                    end
                    write(string.sub(sst, 1, wid))
                    if #sst > wid then
                        setpos(1, hig)
                        write(string.sub(sst, wid, #sst))
                    end
                    local _,op
                    while op ~= "y" and op ~= "n" and op ~= "a" and op ~= "q" do
                        _,op = pullChar()
                        if op == "y" then
                            fs.delete(currSelection.."/"..filesInDir[currDirY + currDirOffset])
                        elseif op == "a" then
                            fs.delete(currSelection)
                            fs.makeDir(currSelection)
                            currDirY = 1
                            currDirOffset = 0
                        elseif op == "q" then
                            running = false
                        end
                    end
                    clearScreenLine(hig)
                    redrawNext = true
                elseif k == "R" then
                    sendMsg("Moving "..shell.resolve(currSelection.."/"..filesInDir[currDirY + currDirOffset]).." to : "..shell.resolve(currSelection).."/")
                    fs.move(shell.resolve(currSelection.."/"..filesInDir[currDirY + currDirOffset]), shell.resolve(currSelection).."/"..read())
                elseif k == "%" then
                    sendMsg("Enter filename: ")
                    local filenamevar = read()
                    if filenamevar then
                        if fs.isDir("/"..shell.resolve(currSelection .. "/" .. filenamevar)) then
                            sendMsg("\"/"..shell.resolve(currSelection .. "/" .. filenamevar).. "\" is a directory")
                            currSelection = currSelection .. "/" .. filenamevar
                            drawDirInfo(currSelection, sortType, currDirY, currDirOffset, filesInDir, true)
                        else
                            return "/"..shell.resolve(currSelection .. "/" .. filenamevar)
                        end
                    end
                elseif k == "-" then
                    currSelection = currSelection .. "/" .. ".."
                    redrawNext = true
                elseif k == "j" then
                    if currDirY + currDirOffset < #filesInDir then
                        currDirY = currDirY + 1
                    end
                    while currDirY > hig - 7 do
                        currDirY = currDirY - 1
                        currDirOffset = currDirOffset + 1
                    end
                elseif k == "k" then
                    if currDirY + currDirOffset > 1 then
                        currDirY = currDirY - 1
                    end
                    while currDirY < 1 do
                        currDirY = currDirY + 1
                        currDirOffset = currDirOffset - 1
                    end
                elseif k == "c" then
                    shell.setDir(currSelection)
                elseif k == "g" then
                    e, k = os.pullEvent("char")
                    if e == "char" then
                        if k == "h" then
                            dothide = not dothide
                            redrawNext = true
                        end
                    end
                elseif k == "r" then
                    reverseSort = not reverseSort
                    redrawNext = true
                end
            elseif e == "key" then
                if k == keys.enter then
                    if fs.isDir(currSelection .. "/" .. filesInDir[currDirY + currDirOffset]) then
                        currSelection = currSelection .. "/" .. filesInDir[currDirY + currDirOffset]
                        currDirY = 1
                        currDirOffset = 0
                        --refresh file list
                        realFilesInDir = fs.list(currSelection)
                        if not (shell.resolve(currSelection) == "") then
                            filesInDir = {".."}
                        else
                            filesInDir = {}
                        end
                        for i=1,#realFilesInDir,1 do
                            table.insert(filesInDir, #filesInDir + 1, realFilesInDir[i])
                        end
                        redrawNext = true
                    else
                        return "/"..shell.resolve(currSelection .. "/" .. filesInDir[currDirY + currDirOffset])
                    end
                    redrawNext = true
                elseif k == keys.down then
                    if currDirY + currDirOffset < #filesInDir then
                        currDirY = currDirY + 1
                    end
                    while currDirY > hig - 7 do
                        currDirY = currDirY - 1
                        currDirOffset = currDirOffset + 1
                    end
                elseif k == keys.up then
                    if currDirY + currDirOffset > 1 then
                        currDirY = currDirY - 1
                    end
                    while currDirY < 1 do
                        currDirY = currDirY + 1
                        currDirOffset = currDirOffset - 1
                    end
                end
            elseif e == "term_resize" then
                resetSize()
                while currDirY > hig - 7 do
                    currDirY = currDirY - 1
                    currDirOffset = currDirOffset + 1
                end
                while currDirY < 1 do
                    currDirY = currDirY + 1
                    currDirOffset = currDirOffset - 1
                end
                drawDirInfo(currSelection, sortType, currDirY, currDirOffset, filesInDir, true)
            end
            if firstDraw then
                firstDraw = false
            end
        end
    else
        error("dirOpener got invalid path: "..dir.." is not a directory.")
    end
end

local lastSearch
local searchPrefix = "/"
--search the current file for a string
local function search(direction, research, currword, wrapSearchPos)
    local localcase = ignorecase
    local oldModeMsg = modeMsg
    local prevMode = currentMode
    currentMode = "c"
    clearScreenLine(hig)
    setcolors(colors.black, colors.white)
    setpos(1, hig)
    if not wrapSearchPos then
        if direction == "forward" then
            searchPrefix = "/"
        else
            searchPrefix = "?"
        end
        write(searchPrefix)
    end
    local currSearch = ""
    local searching = true
    local currline
    if research then
        currSearch = lastSearch
        currline = lastSearchLine
    elseif currword then
        currSearch = currword
        currline = currCursorY + currFileOffset
    else
        --get input
        local currHistoryItem = #sessionSearches + 1
        table.insert(sessionSearches, #sessionSearches + 1, "")
        while searching do
            modeMsg = searchPrefix .. currSearch
            local key = pullTypeaheadWRMP()
            if isCharacterKey(key) then
                local k = getSelfInsert(key)
                currSearch = currSearch .. k
                currHistoryItem = #sessionSearches
                sessionSearches[#sessionSearches] = currSearch
                --move cursor right one and write the next character
                setpos(#currSearch + #k, hig)
                write(k)
            else
                if key == "cr" then
                    searching = false
                elseif key == "bs" then
                    --delete the last character
                    currSearch = string.sub(currSearch, 1, #currSearch - 1)
                    currHistoryItem = #sessionSearches
                    sessionSearches[#sessionSearches] = currSearch
                    --move cursor left one and clear the last character
                    setpos(#currSearch + 2, hig)
                    write(" ")
                elseif key == "up" then
                    if currHistoryItem > 1 then
                        currHistoryItem = currHistoryItem - 1
                        currSearch = sessionSearches[currHistoryItem]
                        setpos(2, hig)
                        write(string.rep(" ", wid - 1))
                        setpos(2, hig)
                        write(currSearch)
                    end
                elseif key == "down" then
                    if currHistoryItem < #sessionSearches then
                        currHistoryItem = currHistoryItem + 1
                        currSearch = sessionSearches[currHistoryItem]
                        setpos(2, hig)
                        write(string.rep(" ", wid - 1))
                        setpos(2, hig)
                        write(currSearch)
                    end
                elseif key == "C-S-v" then
                    expandPaste()
                end
            end
        end
        currline = currCursorY + currFileOffset
    end
    if currSearch ~= "" then
        lastSearch = currSearch
        lastSearchLine = currline
        if not sessionSearches[#sessionSearches] == currSearch then
            table.insert(sessionSearches, #sessionSearches + 1, currSearch)
        end
    end
    if currSearch == nil then
        currSearch = ""
        currline = currCursorY + currFileOffset
    end
    --check if the last 2 characters are \c or \C, adjust the ignorecase variable
    if string.sub(currSearch, #currSearch - 1, #currSearch) == "\\c" then
        localcase = true
        --drop the last 2 characters
        currSearch = string.sub(currSearch, 1, #currSearch - 2)
    elseif string.sub(currSearch, #currSearch - 1, #currSearch) == "\\C" then
        localcase = false
        currSearch = string.sub(currSearch, 1, #currSearch - 2)
    end
    --run through the filelines and find the first line that contains the search string
    local found = false
    local foundLine = nil
    local lowerfunc
    local foundpos
    local currOffset = 0
    if localcase then
        lowerfunc = string.lower
    else
        lowerfunc = function(s) return s end
    end
    local lsp = lastSearchPos or currCursorX + currXOffset
    if wrapSearchPos then
        currline = wrapSearchPos
        lsp = nil
    else
        currline = currCursorY + currFileOffset
    end
    local lastSearchPos = lsp --this way it can be reset only for this search
    --check if there's another instance on the same line forwards or backwards from the word at lastSearchPos
    if lastSearchPos then
        if direction == "forward" then
            local searchCurrLine = lowerfunc(string.sub(filelines[currline], lastSearchPos + 1, #filelines[currline]))
            if string.find(lowerfunc(searchCurrLine), lowerfunc(currSearch)) then
                found = true
                foundLine = currline
                foundpos = string.find(searchCurrLine, lowerfunc(currSearch))
                currOffset = lastSearchPos
            end
        else
            local searchCurrLine = lowerfunc(string.sub(filelines[currline], 1, lastSearchPos - 1))
            local foundat = #searchCurrLine
            for i=foundat, 1, -1 do
                if lowerfunc(searchCurrLine:sub(i, i + #currSearch - 1)) == lowerfunc(currSearch) then
                    found = true
                    foundLine = currline
                    foundpos = i
                    break
                end
            end
        end
    end
    if not found then
        if direction == "forward" then
            for i=currline + 1,#filelines,1 do
                if string.find(lowerfunc(filelines[i]), lowerfunc(currSearch)) then
                    found = true
                    foundLine = i
                    foundpos = string.find(lowerfunc(filelines[i]), lowerfunc(currSearch))
                    break
                end
            end
        else
            for i=currline - 1,1,-1 do
                local foundat = #filelines[i]
                for j=foundat, 1, -1 do
                    if lowerfunc(filelines[i]:sub(j, j + #currSearch - 1)) == lowerfunc(currSearch) then
                        found = true
                        foundLine = i
                        foundpos = j
                        break
                    end
                end
                if found then
                    break
                end
            end
        end
    end
    if found then
        --if the search string is found, move the cursor to the line and scroll to the line
        currCursorY = foundLine
        currFileOffset = 0
        while currCursorY > hig - 1 do
            currCursorY = currCursorY - 1
            currFileOffset = currFileOffset + 1
        end
        if currCursorY < 1 then
            currCursorY = 1
        end
        --set cursor pos to start of the query string
        currCursorX = foundpos + currOffset
        lastSearchPos = currCursorX
        currXOffset = 0
        while currCursorX + lineoffset > wid do
            currCursorX = currCursorX - 1
            currXOffset = currXOffset + 1
        end
        if currCursorX < 1 then
            currCursorX = 1
        end
        redrawTerm()
    else
        if not wrapSearchPos and research then
            if direction == "forward" then
                search(direction, true, currSearch, 1)
                sendMsg("search hit BOTTOM, continuing at TOP")
            else
                search(direction, true, currSearch, #filelines)
                sendMsg("search hit TOP, continuing at BOTTOM")
            end
        else
            err("Pattern not found: "..currSearch)
        end
    end
    modeMsg = oldModeMsg
    currentMode = prevMode
end

local function switchToFile(idx, opts)
    opts = opts or {}
    fileContents[currfile] = filelines
    fileContents[currfile]["cursor"] = {currCursorX, currXOffset, currCursorY, currFileOffset}
    currfile = idx
    if currfile > #fileContents or currfile < 1 then
        currfile = (currfile - 1) % #fileContents + 1
    end
    filelines = fileContents[currfile]
    if fileContents[currfile]["cursor"] then
        currCursorX = fileContents[currfile]["cursor"][1]
        currXOffset = fileContents[currfile]["cursor"][2]
        currCursorY = fileContents[currfile]["cursor"][3]
        currFileOffset = fileContents[currfile]["cursor"][4]
    else
        currCursorX = 1
        currXOffset = 0
        currCursorY = 1
        currFileOffset = 0
    end
    recalcMLCs(true)
    drawFile(true)
    filename = openfiles[currfile]
    if opts.newfile then
        sendMsg("\"" .. filename .."\"  [New File] " .. #filelines .. "L, " .. tab.countchars(filelines) .. "C")
    else
        sendMsg("\"" .. filename .. "\" " .. #filelines .. "L, " .. tab.countchars(filelines) .. "C")
    end
end


for i=1,#decargs,1 do
    if decargs[i] == "--version" then
        print("CCVIM - ComputerCraft Vi IMproved "..version.." ("..releasedate..")")
        do return end --termination
    end
end

if #decargs["files"] > 0 then
    openfiles = decargs["files"]
    for i=1,#openfiles,1 do
        if fs.isDir(fil.topath(decargs["files"][i])) then
            decargs["files"][i] = dirOpener(fil.topath(decargs["files"][i]), decargs["files"][i])
        end
        local nodirectories = fs.getName(decargs["files"][i])
        local filenamestring = ""
        if fs.exists(fil.topath(decargs["files"][i])) then
            local doneGettingEnd = false
            for j=#nodirectories,1,-1 do
                if string.sub(nodirectories, j, j) ~= "." and not doneGettingEnd then
                    filenamestring = string.sub(nodirectories, j, j) .. filenamestring
                else
                    doneGettingEnd = true
                end
            end
            filelines = fil.toArr(fil.topath(decargs["files"][i]))
            fileContents[i] = fil.toArr(fil.topath(decargs["files"][i]))
            if not fileContents[i] then
                error(decargs["files"][i].." failed to load. If this issue persists, please create an issue on the github repository.")
            end
            if filenamestring ~= decargs["files"][i] and filenamestring ~= string.sub(decargs["files"][i], 2, #decargs["files"][i]) then
                fileContents[i]["filetype"] = filenamestring
                if fs.exists("/vim/syntax/"..filenamestring..".lua") then
                    filetypearr[filenamestring] = require("/vim/syntax/"..filenamestring)
                else
                    fileContents[i]["filetype"] = nil
                end
            else
                fileContents[i]["filetype"] = nil
            end
        else
            table.insert(openfiles, #openfiles + 1, decargs["files"][1])
            table.insert(fileContents, #fileContents + 1, {""})
            newfile = true
            local doneGettingEnd = false
            for j=#decargs["files"][i],1,-1 do
                if string.sub(decargs["files"][i], j, j) ~= "." and not doneGettingEnd then
                    filenamestring = string.sub(decargs["files"][i], j, j) .. filenamestring
                else
                    doneGettingEnd = true
                end
            end
            if filenamestring ~= decargs["files"][i] and filenamestring ~= string.sub(decargs["files"][i], 2, #decargs["files"][i]) then
                fileContents[i]["filetype"] = filenamestring
                if fs.exists("/vim/syntax/"..filenamestring..".lua") then
                    filetypearr[filenamestring] = require("/vim/syntax/"..filenamestring)
                else
                    fileContents[i]["filetype"] = nil
                end
            else
                fileContents[i]["filetype"] = nil
            end
        end
        local multilinesInFile = {{}, {}, {}} --beginning quote points, regular quote points, end quote points
        local synt
        if filenamestring ~= decargs["files"][i] and filenamestring ~= string.sub(decargs["files"][i], 2, #decargs["files"][i]) then
            if fs.exists("/vim/syntax/"..filenamestring..".lua") then
                local tmp = require("/vim/syntax/"..filenamestring)
                synt = tmp.syntax()
            end
        end
        if synt then
            local quotepoints = {}
            local justset = false
            for j=1,#fileContents[i],1 do
                local quotationmarks = str.indicesOfLetter(fileContents[i][j], synt[3])
                local quoteSet = tab.itemIndices(quotationmarks)
                local inquotes = false
                justset = false
                for k=1,#fileContents[i][j],1 do
                    if quoteSet[k] then
                        if not inquotes then
                            if k < quotationmarks[#quotationmarks] then
                                inquotes = true
                                justset = true
                            end
                        end
                    end
                    if inquotes then
                        table.insert(quotepoints, #quotepoints, k - 2)
                    end
                    if quoteSet[k] and not justset then
                        if inquotes then
                            inquotes = false
                        end
                    end
                    justset = false
                end
            end
            local inmulti = false
            justset = false
            for j=1,#fileContents[i],1 do
                if str.find(fileContents[i][j], synt[7][1], quotepoints) and not inmulti then
                    inmulti = true
                    justset = true
                    table.insert(multilinesInFile[1], #multilinesInFile[1] + 1, j)
                end
                if inmulti and not (str.find(fileContents[i][j], synt[7][2])) and not justset then
                    table.insert(multilinesInFile[2], #multilinesInFile[2] + 1, j)
                end
                if str.find(fileContents[i][j], synt[7][2]) then
                    if inmulti then
                        inmulti = false
                        table.insert(multilinesInFile[3], #multilinesInFile[3] + 1, j)
                    end
                end
                justset = false
            end
            fileContents[i]["Multi-line comments"] = multilinesInFile
        end
    end
    filelines = fileContents[1]
    filename = decargs["files"][1]
    if filelines[1] ~= nil then
        local tb = str.wordBeginnings(filelines[1])
        if tb[1] then
            currCursorX = tb[1]
        else
            currCursorX = 1
        end
        while currCursorX + lineoffset > wid do
            currCursorX = currCursorX - 1
            currXOffset = currXOffset + 1
        end
        lastSearchPos = nil
        lastSearchLine = nil
    end
else
    openfiles = {""}
    filelines = {""}
    fileContents[1] = filelines
    currfile = 1
end

if not (#openfiles > 0) then
    setcolors(colors.black, colors.white)
    clear()
    resetSize()
    setcolors(colors.black, colors.purple)
    for i=2,hig - 1,1 do
        setpos(1,i)
        write("~")
    end
    --MOTD
    motd = true
    setcolors(colors.black, colors.white)
    setpos((wid / 2) - (33 / 2), (hig / 2) - 3)
    write("CCVIM - ComputerCraft Vi Improved")
    setpos((wid / 2) - (#("version ".. version) / 2), (hig / 2) - 1)
    write("version "..version)
    setpos((wid / 2) - (13 / 2), (hig / 2))
    write("By Minater247")
    if wid > 53 then
        setpos((wid / 2) - (46 / 2), (hig / 2) + 1)
        write("CCVIM is open source and freely distributable.")
        setpos((wid / 2) - (28 / 2), (hig / 2) + 4)
    else
        setpos((wid / 2) - (28 / 2), (hig / 2) + 3)
    end
    write("Type :q")
    setcolors(colors.black, colors.lightBlue)
    write("<Enter>       ")
    setcolors(colors.black, colors.white)
    write("to exit")

    setpos(1, 1)
    setcolors(colors.lightGray, colors.white)
    write(" ")
else
    drawFile(true)
    if newfile then
        sendMsg("\""..filename.."\" [New File]")
    else
        sendMsg("\""..filename.."\" "..#filelines.."L, "..tab.countchars(filelines).."C")
    end
end

registerAction(":", function()
            clearScreenLine(hig)
            local cmd = pullCommand(":", false)
            local cmdtab = str.split(cmd, " ")
            lastSearchPos = nil
            lastSearchLine = nil
            if cmd:sub(1, 2) == ":!" then
                local oldCursor = {term.getCursorPos()}
                term.setCursorPos(1, hig)
                setcolors(colors.black, colors.white)
                shell.run(cmd:sub(3, 4))
                print("Exited, press enter to continue...")
                local _, k = os.pullEvent("key")
                while k ~= keys.enter do
                    _, k = os.pullEvent("key")
                end
                resetSize()
                redrawTerm()
            elseif cmdtab[1] == ":sav" or cmdtab[1] == ":saveas" or cmdtab[1] == ":sav!" or cmdtab[1] == ":saveas!" then
                local name = ""
                for i=2,#cmdtab,1 do
                    name = name .. cmdtab[i]
                    if i ~= #cmdtab then
                        name = name .. " "
                    end
                end
                if #cmdtab < 2 then
                    err("Argument required")
                elseif fs.exists(fil.topath(name)) and not (cmdtab[1] == ":sav!" or cmdtab[1] == ":saveas!") then
                    err("File exists (add ! to override)")
                elseif fs.isReadOnly(fil.topath(name)) then
                    err("File is read-only")
                else
                    local new = true
                    if fs.exists(fil.topath(name)) then
                        new = false
                    end
                    local file = fs.open(fil.topath(name), "w")
                    for i=1,#filelines,1 do
                        file.writeLine(filelines[i])
                    end
                    file.close()
                    fileContents[currfile]["unsavedchanges"] = false
                    sendMsg("\""..name.."\" ")
                    if new then
                        write("[New]  ")
                    else
                        write(" ")
                    end
                    write(#filelines.."L written")
                end
            elseif cmdtab[1] == ":w" or cmdtab[1] == ":w!" then
                local name = ""
                if #cmdtab > 1 then
                    for i=2,#cmdtab,1 do
                        name = name .. cmdtab[i]
                        if i ~= #cmdtab then
                            name = name .. " "
                        end
                    end
                else
                    name = filename
                end
                if #cmdtab < 2 and filename == "" then
                    err("No file name")
                elseif fs.isReadOnly(fil.topath(name)) then
                    err("File is read-only")
                else
                    local new = true
                    if fs.exists(fil.topath(name)) then
                        new = false
                    end
                    local fl = fs.open(fil.topath(name), "w")
                    for i=1,#filelines,1 do
                        fl.writeLine(filelines[i])
                    end
                    fl.close()
                    fileContents[currfile]["unsavedchanges"] = false
                    sendMsg("\""..name.."\" ")
                    if new then
                        write("[New]  ")
                    else
                        write(" ")
                    end
                    write(#filelines.."L written")
                end
            elseif cmdtab[1] == ":q" or cmdtab[1] == ":q!" then
                if not fileContents[currfile] then
                    fileContents[currfile] = {""}
                end
                if fileContents[currfile]["unsavedchanges"] and cmdtab[1] ~= ":q!" then
                    err("No write since last change (add ! to override)")
                else
                    if #fileContents <= 1 then
                        setcolors(colors.black, colors.white)
                        clear()
                        setpos(1, 1)
                        running = false
                    else
                        local oldfile = currfile
                        clearScreenLine(hig)
                        switchToFile(currfile - 1)
                        table.remove(fileContents, oldfile)
                        table.remove(openfiles, oldfile)
                    end
                end
            elseif cmdtab[1] == ":wq" or cmdtab[1] == ":x" then
                local name = ""
                if openfiles[currfile] == "" then
                    for i=2,#cmdtab,1 do
                        name = name .. cmdtab[i]
                        if i ~= #cmdtab then
                            name = name .. " "
                        end
                    end
                else
                    name = openfiles[currfile]
                end
                if name then
                    if cmdtab[2] == nil and openfiles[currfile] == "" then
                        err("No file name")
                    elseif fs.isReadOnly(fil.topath(name)) then
                        err("File is read-only")
                    else
                        if name then
                            local file = fs.open(fil.topath(name), "w")
                            for i=1,#filelines,1 do
                                file.writeLine(filelines[i])
                            end
                            file.close()
                            fileContents[currfile]["unsavedchanges"] = false
                            if #fileContents == 1 then
                                setcolors(colors.black, colors.white)
                                clear()
                                setpos(1, 1)
                                running = false
                            else
                                local oldfile = currfile
                                clearScreenLine(hig)
                                switchToFile(currfile - 1)
                                table.remove(fileContents, oldfile)
                                table.remove(openfiles, oldfile)
                            end
                        end
                    end
                else
                    err("No file name")
                end
            elseif cmdtab[1] == ":e" or cmdtab[1] == ":ex" then
                if #cmdtab > 1 then
                    if not motd then
                        if currfile == 0 then
                            currfile = 1
                        end
                        fileContents[currfile] = filelines
                        fileContents[currfile]["cursor"] = {currCursorX, currXOffset, currCursorY, currFileOffset}
                        if not openfiles[currfile] then
                            openfiles[currfile] = ""
                        end
                    end
                    local name = ""
                    for i=2,#cmdtab,1 do
                        name = name .. cmdtab[i]
                        if i ~= #cmdtab then
                            name = name .. " "
                        end
                    end
                    if name then
                        if fs.isDir(fil.topath(name)) then
                            filename = dirOpener(fil.topath(name))
                        else
                            filename = name
                        
                        end
                    else
                        filename = ""
                    end
                    table.insert(openfiles, #openfiles + 1, filename)
                    if currfile == 0 then
                        currfile = 1
                    end
                    newfile = false
                    if fs.exists(fil.topath(filename)) then
                        filelines = fil.toArr(fil.topath(filename))
                        if filelines then
                            sendMsg("\""..filename.."\" "..#filelines.."L, "..tab.countchars(filelines).."C")
                        else
                            newfile = true
                            sendMsg("\""..filename.."\" [New File]")
                        end
                    else
                        newfile = true
                        sendMsg("\""..filename.."\" [New File]")
                    end
                    table.insert(fileContents, #fileContents + 1, fil.toArr(fil.topath(filename)))
                    if not fileContents[#fileContents] then
                        fileContents[#fileContents] = {""}
                    end
                    currfile = #fileContents
                    filelines = fileContents[currfile]
                    currFileOffset = 0
                    if filelines[1] ~= nil then
                        local tb = str.wordBeginnings(filelines[1])
                        if tb[1] then
                            currCursorX = tb[1]
                        else
                            currCursorX = 1
                        end
                        while currCursorX + lineoffset > wid do
                            currCursorX = currCursorX - 1
                            currXOffset = currXOffset + 1
                        end
                    end
                    local doneGettingEnd = false
                    local filenamestring = string.sub(openfiles[currfile], string.find(openfiles[currfile], "%.") + 1, #openfiles[currfile])
                    if filenamestring ~= openfiles[currfile] and filenamestring ~= string.sub(openfiles[currfile], 2, #openfiles[currfile]) then
                        fileContents[currfile]["filetype"] = filenamestring
                        if fs.exists("/vim/syntax/"..filenamestring..".lua") then
                            filetypearr[filenamestring] = require("/vim/syntax/"..filenamestring)
                        else
                            fileContents[currfile]["filetype"] = nil
                        end
                    else
                        fileContents[currfile]["filetype"] = nil
                    end
                    if newfile then
                        moveCursorRight()
                    end
                    recalcMLCs(true)
                    drawFile(true)
                else
                    err("No file name")
                end
            elseif cmdtab[1] == ":r" or cmdtab[1] == ":read" then
                if #cmdtab > 1 then
                    local name = ""
                    for i=2,#cmdtab,1 do
                        name = name .. cmdtab[i]
                        if i ~= #cmdtab then
                            name = name .. " "
                        end
                    end
                    if fs.exists(fil.topath(name)) then
                        if fs.isDir(fil.topath(name)) then
                            name = dirOpener(fil.topath(name))
                        end
                        local secondArr = fil.toArr(fil.topath(name))
                        for i=1,#secondArr,1 do
                            table.insert(filelines, #filelines + 1, secondArr[i])
                        end
                        if not fileContents[currfile] then
                            fileContents[currfile] = filelines
                        end
                        recalcMLCs(true)
                        drawFile(true)
                        sendMsg("\""..name.."\" "..#secondArr.."L, "..tab.countchars(secondArr).."C")
                        motd = false
                    else
                        err("Can't open file "..name)
                    end
                else
                    err("No file name")
                end
            elseif cmdtab[1] == ":tabn" or cmdtab[1] == ":tabnext" then
                if #fileContents > 1 then
                    switchToFile(currfile + 1)
                end
            elseif cmdtab[1] == ":tabp" or cmdtab[1] == ":tabprevious" then
                if #fileContents > 1 then
                    switchToFile(currfile - 1)
                end
            elseif cmdtab[1] == ":tabm" or cmdtab[1] == ":tabmove" then
                local tmp = tonumber(cmdtab[2])
                if tonumber(cmdtab[2]) >= 0 and tonumber(cmdtab[2]) <= #fileContents - 1 then
                    -- This is not what :tabmove should do!
                    switchToFile(tonumber(cmdtab[2]) + 1)
                end
                clearScreenLine(hig)
            elseif cmdtab[1] == ":tabo" or cmdtab[1] == ":tabonly" or cmdtab[1] == ":tabo!" or cmdtab[1] == ":tabonly!" then
                local closable = true
                local unclosablename = ""
                local unclosablenum = -1
                for i=1,#fileContents,1 do
                    if fileContents[i]["unsavedchanges"] and not (i == currfile) and cmdtab[1] ~= ":tabo!" and cmdtab[1] ~= ":tabonly!" then
                        closable = false
                        unclosablename = openfiles[i]
                        unclosablenum = i
                    end
                end
                if not closable then
                    err("Unsaved work in \""..unclosablename.."\" (add ! to override)")
                else
                    fileContents = {fileContents[currfile]}
                    openfiles = {openfiles[currfile]}
                    currfile = 1
                    filelines = fileContents[currfile]
                    if fileContents[currfile]["cursor"] then
                        currCursorX = fileContents[currfile]["cursor"][1]
                        currXOffset = fileContents[currfile]["cursor"][2]
                        currCursorY = fileContents[currfile]["cursor"][3]
                        currFileOffset = fileContents[currfile]["cursor"][4]
                    end
                    drawFile()
                    clearScreenLine(hig)
                    sendMsg("\"" .. filename .. "\" " .. #filelines .. "L, " .. tab.countchars(filelines) .. "C")
                end
            elseif cmdtab[1] == ":tabnew" then
                if not cmdtab[2] then
                    cmdtab[2] = 1
                end
                if tonumber(cmdtab[2]) ~= nil then
                    for i=1,tonumber(cmdtab[2]),1 do
                        table.insert(fileContents, currfile + 1, {""})
                        table.insert(openfiles, currfile + 1, "")
                    end
                    sendMsg("added "..tonumber(cmdtab[2]).." new tab")
                    if tonumber(cmdtab[2]) > 1 then
                        write("s")
                    end
                    switchToFile(currfile + 1)
                else
                    if cmdtab[2] then
                        local name = ""
                        for i=2,#cmdtab,1 do
                            name = name .. cmdtab[i]
                            if i ~= #cmdtab then
                                name = name .. " "
                            end
                        end
                        if fs.exists(fil.topath(name)) then
                            if fs.isDir(fil.topath(name)) then
                                name = dirOpener(fil.topath(name))
                            else
                                name = fil.topath(name)
                            end
                            table.insert(fileContents, currfile + 1, fil.toArr(fil.topath(name)))
                            local newfile = false
                            if not fileContents[#fileContents] then
                                newfile = true
                                fileContents[#fileContents] = {""}
                            end
                            table.insert(openfiles, currfile + 1, name)
                            switchToFile(currfile + 1, {newfile = newfile})
                            local tb = str.wordBeginnings(filelines[1])
                            if tb[1] then
                                currCursorX = tb[1]
                            else
                                currCursorX = 1
                            end
                            while currCursorX + lineoffset > wid do
                                currCursorX = currCursorX - 1
                                currXOffset = currXOffset + 1
                            end
                            if string.find(openfiles[currfile], "%.") then
                                local filenamestring = string.sub(openfiles[currfile], string.find(openfiles[currfile], "%.") + 1, #openfiles[currfile])
                                if fs.exists("/vim/syntax/"..filenamestring..".lua") then
                                    filetypearr[filenamestring] = require("/vim/syntax/"..filenamestring)
                                else
                                    fileContents[currfile]["filetype"] = nil
                                end
                                fileContents[currfile]["filetype"] = filenamestring
                            end
                            recalcMLCs(true)
                            drawFile(true)
                        else
                            name = fil.topath(name)
                            local templines = fil.toArr(name)
                            if templines then
                                table.insert(fileContents, currfile + 1, templines)
                            else
                                table.insert(fileContents, currfile + 1, {""})
                            end
                            table.insert(openfiles, currfile + 1, name)
                            switchToFile(currfile + 1, {newfile = newfile})
                            if string.find(openfiles[currfile], "%.") then
                                local filenamestring = string.sub(openfiles[currfile], string.find(openfiles[currfile], "%.") + 1, #openfiles[currfile])
                                if fs.exists("/vim/syntax/"..filenamestring..".lua") then
                                    filetypearr[filenamestring] = require("/vim/syntax/"..filenamestring)
                                else
                                    fileContents[currfile]["filetype"] = nil
                                end
                                fileContents[currfile]["filetype"] = filenamestring
                            end
                            recalcMLCs(true)
                            drawFile(true)
                        end
                    else
                        --just add an empty tab
                        table.insert(fileContents, currfile + 1, {""})
                        table.insert(openfiles, currfile + 1, "")
                        switchToFile(currfile + 1)
                    end
                end
                if string.find(openfiles[currfile], "%.") then
                    fileContents[currfile]["filetype"] = string.sub(openfiles[currfile], string.find(openfiles[currfile], "%.") + 1, #openfiles[currfile])
                end
            elseif cmdtab[1] == ":tabc" or cmdtab[1] == ":tabclose" or cmdtab[1] == ":tabc!" or cmdtab[1] == ":tabclose!" then
                if fileContents[currfile]["unsavedchanges"] and cmdtab[1] ~= ":tabc!" and cmdtab[1] ~= ":tabclose!" then
                    err("No write since last change (add ! to override)")
                else
                    if #fileContents == 1 then
                        setcolors(colors.black, colors.white)
                        clear()
                        setpos(1, 1)
                        running = false
                    else
                        local oldfile = currfile
                        clearScreenLine(hig)
                        switchToFile(currfile - 1)
                        table.remove(fileContents, oldfile)
                        table.remove(openfiles, oldfile)
                    end
                end
            elseif cmdtab[1] == ":set" then
                local seterror = false
                if cmdtab[2] == "number" then
                    linenumbers = true
                    lineoffset= 4
                    drawFile(true)
                elseif cmdtab[2] == "mobile" then
                    mobile = true
                elseif cmdtab[2] == "nonumber" then
                    linenumbers = false
                    lineoffset = 0
                    drawFile(true)
                elseif cmdtab[2] == "nomobile" then
                    mobile = false
                elseif cmdtab[2] == "lowspec" then
                    lowspec = true
                    drawFile(true)
                elseif cmdtab[2] == "nolowspec" then
                    lowspec = false
                    drawFile(true)
                elseif cmdtab[2] == "scroll?" then
                    -- FIXME message seems to be immediately disappear
                    sendMsg("  scroll=" .. scrollOption)
                elseif str.find(cmdtab[2], "=") then
                    local tmp = str.split(cmdtab[2], "=")
                    local comm = tmp[1]
                    local stri = ""
                    for i=2,#tmp,1 do
                        stri = stri .. tmp[i]
                        if i ~= #tmp then
                            stri = stri .. "="
                        end
                    end
                    if comm == "filetype" then
                        if stri ~= openfiles[currfile] and stri ~= string.sub(openfiles[currfile], 2, #openfiles[currfile]) then
                            fileContents[currfile]["filetype"] = stri
                            if fs.exists("/vim/syntax/"..stri..".lua") then
                                filetypearr[stri] = require("/vim/syntax/"..stri)
                            else
                                fileContents[currfile]["filetype"] = nil
                            end
                        else
                            fileContents[currfile]["filetype"] = nil
                        end
                    elseif comm == "scale" then
                        if monitor and tonumber(stri) then
                            monitor.setTextScale(tonumber(stri))
                        end
                    elseif comm == "scroll" then
                        if tonumber(stri) then
                            scrollOption = tonumber(stri)
                        end
                    elseif comm == "shiftwidth" or comm == "sw" then
                        if tonumber(stri) then
                            shiftWidth = tonumber(stri)
                        end
                    end
                    resetSize()
                    recalcMLCs(true)
                    redrawTerm()
                    drawFile(true)
                elseif cmdtab[2] == "autoindent" then
                    autoindent = true
                elseif cmdtab[2] == "noautoindent" then
                    autoindent = false
                elseif cmdtab[2] == "ignorecase" or cmdtab[2] == "ic" then
                    ignorecase = true
                elseif cmdtab[2] == "noignorecase" or cmdtab[2] == "noic" then
                    ignorecase = false
                elseif cmdtab[2] == "tmkeyboard" then
                    useTmKeyboards = true
                elseif cmdtab[2] == "notmkeyboard" then
                    useTmKeyboards = false
                else
                    err("Variable " .. cmdtab[2] .. " not supported.")
                    seterror = true
                end
                if not seterror then
                    clearScreenLine(hig)
                end
            elseif cmdtab[1] == ":resetscale" then
                resetSize()
                redrawTerm()
            elseif cmdtab[1] == ":syntax" then
                if cmdtab[2] == "on" then
                    syntaxhighlighting = true
                elseif cmdtab[2] == "off" then
                    syntaxhighlighting = false
                else
                    err("invalid :syntax subcommand: "..cmdtab[2])
                end
                recalcMLCs(true)
                drawFile(true)
            elseif cmdtab[1] == ":control" or cmdtab[1] == ":ctrl" then --not yet working
                local _, ch
                if not cmdtab[2] then
                    sendMsg("Emulating held control until next key press:")
                    _, ch = os.pullEvent("char")  -- TODO pull one key from the typeahead, modify it with ctrl and prepend it again
                    sendMsg("Sent CONTROL + "..ch)
                else
                    ch = cmdtab[2]
                    clearScreenLine(hig)
                end
                if ch == "e" then
                    currFileOffset = currFileOffset + 1
                    currCursorY = currCursorY - 1
                elseif ch == "y" then
                    currFileOffset = currFileOffset - 1
                    currCursorY = currCursorY + 1
                elseif ch == "b" then
                    local oldCursorY = currCursorY
                    if currCursorY + currFileOffset > hig - 1 then
                        currCursorY = currCursorY - (hig - 1)
                    end
                    while currCursorY < oldCursorY do
                        currCursorY = currCursorY + 1
                        currFileOffset = currFileOffset - 1
                    end
                elseif ch == "f" then
                    local oldCursorY = currCursorY
                    if currCursorY + currFileOffset < #filelines - (hig - 1) then
                        currCursorY = currCursorY + (hig - 1)
                    end
                    while currCursorY > oldCursorY do
                        currCursorY = currCursorY - 1
                        currFileOffset = currFileOffset + 1
                    end
                elseif ch == "d" then
                    local oldCursorY = currCursorY
                    if currCursorY + currFileOffset < #filelines - math.floor((hig - 1)/2) then
                        currCursorY = currCursorY + math.floor((hig - 1)/2)
                    end
                    while currCursorY > oldCursorY do
                        currCursorY = currCursorY - 1
                        currFileOffset = currFileOffset + 1
                    end
                    while currFileOffset > #filelines - (hig - 1) do
                        currFileOffset = currFileOffset - 1
                        currCursorY = currCursorY + 1
                    end
                elseif ch == "u" then
                    local oldCursorY = currCursorY
                    if currCursorY + currFileOffset > (hig - 1) then
                        currCursorY = currCursorY - math.floor((hig - 1)/2)
                    end
                    while currCursorY < oldCursorY do
                        currCursorY = currCursorY + 1
                        currFileOffset = currFileOffset - 1
                    end
                    while currFileOffset < 0 do
                        currFileOffset = currFileOffset + 1
                        currCursorY = currCursorY - 1
                    end
                end
                drawFile()
            elseif cmdtab[1] == ":dbgex" then --debug 
                local ff = fs.open("/vim/debug.exp", "w")
                ff.write("Line offset: "..lineoffset.."\n")
                ff.write("Cursor Y: "..currCursorY.."\n")
                ff.write("Cursor X: "..currCursorX.."\n")
                ff.write("File offset: "..currFileOffset.."\n")
                ff.write("Cursor X offset: "..currXOffset.."\n")
                ff.write("Last search: "..lastSearch.."\n")
                ff.write("Last search line gotten: "..lastSearchLine.."\n")
                for i=1,#filelines,1 do
                    ff.write(filelines[i].."\n")
                end
                ff.close()
            elseif cmdtab[1] ~= "" then
                err("Not an editor command or unimplemented: "..cmdtab[1])
            end
        end)
registerAction("i", function()
            insertMode()
        end)
registerAction("I", function()
    performMotion(nil, textObjectSOL)
    insertMode()
end)
registerMotionMulti({{"h", "<left>"}}, function()
    return {exclusive = true}, (function(opts)
        opts.x = opts.x - repeatCount1
        if opts.x < 1 then
            opts.x = 1
        end
        opts.wantX = nil
        return opts
    end)
end)
registerMotionMulti({{"j", "<down>"}}, function()
    return {}, (function(opts)
        if opts.linewise == nil then  -- preserve false
            opts.linewise = true
        end
        if opts.wantX ~= nil then
            opts.x = opts.wantX
        else
            opts.wantX = opts.x
        end
        opts.y = opts.y + repeatCount1
        if opts.y > #filelines then
            opts.y = #filelines
        end
        local line = filelines[opts.y]
        if opts.x > #line + 1 then
            opts.x = #line + 1
        end
        return opts
    end)
end)
registerMotionMulti({{"k", "<up>"}}, function()
    return {}, (function(opts)
        if opts.linewise == nil then  -- preserve false
            opts.linewise = true
        end
        if opts.wantX ~= nil then
            opts.x = opts.wantX
        else
            opts.wantX = opts.x
        end
        opts.y = opts.y - repeatCount1
        if opts.y < 1 then
            opts.y = 1
        end
        local line = filelines[opts.y]
        if opts.x > #line + 1 then
            opts.x = #line + 1
        end
        return opts
    end)
end)
registerMotionMulti({{"l", "<right>"}}, function()
    return {exclusive = true}, (function(opts)
        opts.x = opts.x + repeatCount1
        if opts.x < 1 then
            opts.x = 1
        end
        local line = filelines[opts.y]
        opts.wantX = nil
        return opts
    end)
end)
registerMotion("H", {}, function(opts)
    if opts.linewise == nil then
        opts.linewise = true
    end
    opts.y = currFileOffset + 1
    if opts.y < 1 then
        opts.y = 1
    elseif opts.y > #filelines then
        opts.y = #filelines
    end
    local line = filelines[opts.y]
    opts.x = line:find("[^ \x09]") or #line
    if opts.x < 1 then
        opts.x = 1
    end
    opts.wantX = nil
    return opts
end)
registerMotion("M", {}, function(opts)
    if opts.linewise == nil then
        opts.linewise = true
    end
    opts.y = currFileOffset + math.floor((hig - 1) / 2)
    if opts.y < 1 then
        opts.y = 1
    elseif opts.y > #filelines then
        opts.y = #filelines
    end
    local line = filelines[opts.y]
    opts.x = line:find("[^ \x09]") or #line
    if opts.x < 1 then
        opts.x = 1
    end
    opts.wantX = nil
    return opts
end)
registerMotion("L", {}, function(opts)
    if opts.linewise == nil then
        opts.linewise = true
    end
    opts.y = currFileOffset + (hig - 1)
    if opts.y < 1 then
        opts.y = 1
    elseif opts.y > #filelines then
        opts.y = #filelines
    end
    local line = filelines[opts.y]
    opts.x = line:find("[^ \x09]") or #line
    if opts.x < 1 then
        opts.x = 1
    end
    opts.wantX = nil
    return opts
end)
registerAction("r", function()
            local chr = pullTypeaheadCharMode("i")
            filelines[currCursorY + currFileOffset] = string.sub(filelines[currCursorY + currFileOffset], 1, currCursorX + currXOffset - 1) .. chr .. string.sub(filelines[currCursorY + currFileOffset], currCursorX + currXOffset + 1, #(filelines[currCursorY + currFileOffset]))
            recalcMLCs()
            drawFile(true)
            if fileContents[currfile] then
                fileContents[currfile]["unsavedchanges"] = true
            end
        end)
registerAction("J", function()
            if filelines[currCursorY + currFileOffset] and filelines[currCursorY + currFileOffset + 1] then
                filelines[currCursorY + currFileOffset] = filelines[currCursorY + currFileOffset] .. " " .. filelines[currCursorY + currFileOffset + 1]
                table.remove(filelines, currCursorY + currFileOffset + 1)
                recalcMLCs()
                drawFile(true)
                fileContents[currfile]["unsavedchanges"] = true
            end
        end)
registerAction("o", function()
    resetLastSearch()
    local line = filelines[currCursorY + currFileOffset]
    local indentedamount = 0
    if autoindent then
        indentedamount = (line:find("[^ \x09]") or #line + 1) - 1
    end
    table.insert(filelines, currCursorY + currFileOffset + 1, line:sub(1, indentedamount))
    moveCursorDown()
    currCursorX = indentedamount + 1 - currXOffset
    if currCursorX + lineoffset > wid then
        local delta = wid - currCursorX - lineoffset
        currCursorX = currCursorX + delta
        currXOffset = currXOffset - delta
    elseif currCursorX < 1 then
        currXOffset = currXOffset + currCursorX - 1
        currCursorX = 1
        if currXOffset < 0 then
            currXOffset = 0
        end
    end
    recalcMLCs()
    drawFile(true)
    insertMode()
    if fileContents[currfile] then
        fileContents[currfile]["unsavedchanges"] = true
    end
end)
registerAction("O", function()
    resetLastSearch()
    local line = filelines[currCursorY + currFileOffset]
    local indentedamount = 0
    if autoindent then
        indentedamount = (line:find("[^ \x09]") or #line + 1) - 1
    end
    table.insert(filelines, currCursorY + currFileOffset, line:sub(1, indentedamount))
    currCursorX = indentedamount + 1 - currXOffset
    if currCursorX + lineoffset > wid then
        local delta = wid - currCursorX - lineoffset
        currCursorX = currCursorX + delta
        currXOffset = currXOffset - delta
    elseif currCursorX < 1 then
        currXOffset = currXOffset + currCursorX - 1
        currCursorX = 1
        if currXOffset < 0 then
            currXOffset = 0
        end
    end
    recalcMLCs()
    drawFile(true)
    insertMode()
    fileContents[currfile]["unsavedchanges"] = true
end)
registerAction("a", function()
            moveCursorRight(0)
            insertMode()
        end)
registerAction("A", function()
            lastSearchPos = nil
            lastSearchLine = nil
            currCursorX = #filelines[currCursorY + currFileOffset]
            currXOffset = 0
            while currCursorX + lineoffset > wid do
                currXOffset = currXOffset + 1
                currCursorX = currCursorX - 1
            end
            drawFile()
            moveCursorRight(0)
            insertMode()
        end)
registerAction("ZQ", function()
                setcolors(colors.black, colors.white)
                clear()
                setpos(1, 1)
                running = false
            end)
registerAction("ZZ", function()
                if filename == "" then
                    err("No file name")
                else
                    local file = fs.open(fil.topath(filename), "w")
                    for i=1,#filelines,1 do
                        file.writeLine(filelines[i])
                    end
                    file.close()
                    fileContents[currfile]["unsavedchanges"] = false
                    setcolors(colors.black, colors.white)
                    clear()
                    setpos(1, 1)
                    running = false
                end
            end)
local cutTextObject
local yankTextObject
registerAction("yy", function()
    resetLastSearch()
    yankTextObject(textObjectLine())
end)
registerAction("y", function()
    resetLastSearch()
    local to = pullTextObject()
    if to == nil then
        sendMsg("No text object")
        return
    end
    local prevCurY = currCursorY
    yankTextObject(to, true)
    scrollToCursor()
    local dy = currCursorY - prevCurY
    drawFile(dy < -1 or dy > 1)
end)
registerVisualAction("y", function()
    resetLastSearch()
    yankTextObject(textObjectLine())
    return true
end)
registerAction("Y", function()
    resetLastSearch()
    yankTextObject(textObjectEOL())  -- drop Vi compatibility
end)
registerAction("x", function()
    local beg = currCursorX + currXOffset
    local ed = beg + repeatCount1 - 1
    local line = filelines[currCursorY + currFileOffset]
    if ed > #line then
        ed = #line
    end
    copybuffer = string.sub(line, beg, ed)
    copytype = "text"
    filelines[currCursorY + currFileOffset] = string.sub(line, 1, beg - 1) .. string.sub(line, ed + 1, #line)
    recalcMLCs()
    drawFile()
    if fileContents[currfile] then
        fileContents[currfile]["unsavedchanges"] = true
    end
end)
registerAction("X", function()
    local ed = currCursorX + currXOffset - 1
    local beg = ed - repeatCount1 + 1
    if beg < 1 then
        beg = 1
    end
    if ed < beg then
        -- Real Vim pushes undo state, but does not erase the register or mark the file as modified
        return
    end
    local line = filelines[currCursorY + currFileOffset]
    copybuffer = string.sub(line, beg, ed)
    copytype = "text"
    filelines[currCursorY + currFileOffset] = string.sub(line, 1, beg - 1) .. string.sub(line, ed + 1, #line)
    recalcMLCs()
    drawFile()
    if fileContents[currfile] then
        fileContents[currfile]["unsavedchanges"] = true
    end
end)
function resetLastSearch()
            lastSearchPos = nil
            lastSearchLine = nil
        end
local afterDelete
registerAction("dd", function()
    resetLastSearch()
    cutTextObject(textObjectLine())
end)
registerAction("d", function()
    resetLastSearch()
    local to = pullTextObject()
    if to == nil then
        sendMsg("No text object")
        return
    end
    cutTextObject(to)
end)
registerVisualAction("d", function()
    resetLastSearch()
    cutTextObject(visualModeState)
    return true
end)
function cutTextObject(to, settings)
    settings = settings or {}
    local addLine = settings.addLine or false
    local onePastEOL = settings.onePastEOL or false
    local begX, begY, edX, edY = to.initialX, to.initialY, to.x, to.y
    if edY < begY or edY == begY and edX < begX then
        begX, edX = edX, begX
        begY, edY = edY, begY
    end
    if to.linewise then
        copybuffer = {}
        for i = begY, edY do
            table.insert(copybuffer, #copybuffer + 1, filelines[i])
        end
        copytype = "linetable"
        for _ = begY, edY do
            table.remove(filelines, begY)
        end
        fileContents[currfile]["unsavedchanges"] = true
        if currCursorY + currFileOffset > begY then
            if currCursorY + currFileOffset > edY then
                currCursorY = currCursorY - (edY - begY) - 1
            else
                currCursorY = begY - currFileOffset
            end
        end
        if addLine or #filelines < 1 then
            local i = currCursorY + currFileOffset
            if i > #filelines + 1 then
                i = #filelines + 1
            elseif i < 1 then
                i = 1
            end
            local newLine = ""
            if autoindent then
                local protoLine = filelines[i - 1] or filelines[i] or ""
                local indentedamount = (protoLine:find("[^ \x09]") or #protoLine + 1) - 1
                newLine = protoLine:sub(1, indentedamount)
            end
            table.insert(filelines, i, newLine)
            currCursorX = #newLine - currXOffset
            if onePastEOL then
                currCursorX = currCursorX + 1
            end
        end
    else
        if to.exclusive then
            edX = edX - 1
            if begY == edY and edX < begX then
                -- push undo state
                return true
            end
            if edX < 1 then
                edY = edY - 1
                -- SAFETY: edY >= 1 because begY >= 1 and edY >= begY
                edX = #filelines[edY]
            end
        end
        if begY ~= edY then
            local begLine = filelines[begY]
            local edLine = filelines[edY]
            copybuffer = {begLine:sub(begX), edLine:sub(1, edX)}
            for i = begY + 1, edY - 1 do
                table.insert(copybuffer, #copybuffer, filelines[i])
            end
            copytype = "texttable"
            filelines[begY] = begLine:sub(1, begX - 1) .. edLine:sub(edX + 1)
            for _ = begY + 1, edY do
                table.remove(filelines, begY + 1)
            end
            fileContents[currfile]["unsavedchanges"] = true
            if begY == currCursorY + currFileOffset and currCursorX + currXOffset > begX or currCursorY + currFileOffset > begY then
                if edY == currCursorY + currFileOffset and currCursorX + currXOffset > edX  then
                    currCursorX = currCursorX - edX + begX - 1
                    currCursorY = begY - currFileOffset
                elseif currCursorY + currFileOffset > edY then
                    currCursorY = currCursorY - (edY - begY)
                else
                    currCursorX = begX - currXOffset
                    currCursorY = begY - currFileOffset
                end
            end
        else
            local line = filelines[begY]
            copybuffer = string.sub(line, begX, edX)
            copytype = "text"
            filelines[begY] = string.sub(line, 1, begX - 1) .. string.sub(line, edX + 1, #line)
            fileContents[currfile]["unsavedchanges"] = true
            if begY == currCursorY + currFileOffset and currCursorX + currXOffset > begX then
                if currCursorX + currXOffset > edX then
                    currCursorX = currCursorX - (edX - begX + 1)
                else
                    currCursorX = begX - currXOffset
                end
            end
        end
    end
    afterDelete({onePastEOL = onePastEOL})
    return true
end
function yankTextObject(to, jumpBeg)
    local begX, begY, edX, edY = to.initialX, to.initialY, to.x, to.y
    if edY < begY or edY == begY and edX < begX then
        begX, edX = edX, begX
        begY, edY = edY, begY
    end
    if to.linewise then
        copybuffer = {}
        for i = begY, edY do
            table.insert(copybuffer, #copybuffer + 1, filelines[i])
        end
        copytype = "linetable"
        if jumpBeg then
            currCursorY = begY
        end
    else
        if to.exclusive then
            edX = edX - 1
            if begY == edY and edX < begX then
                if jumpBeg then
                    currCursorX = begX
                    currCursorY = begY
                end
                return true
            end
            if edX < 1 then
                edY = edY - 1
                -- SAFETY: edY >= 1 because begY >= 1 and edY >= begY
                edX = #filelines[edY]
            end
        end
        if begY ~= edY then
            local begLine = filelines[begY]
            local edLine = filelines[edY]
            copybuffer = {begLine:sub(begX), edLine:sub(1, edX)}
            for i = begY + 1, edY - 1 do
                table.insert(copybuffer, #copybuffer, filelines[i])
            end
            copytype = "texttable"
        else
            local line = filelines[begY]
            copybuffer = string.sub(line, begX, edX)
            copytype = "text"
        end
    end
    if jumpBeg then
        currCursorX = begX
        currCursorY = begY
    end
    return true
end
registerTextObjectMulti({{"i", "a"}, {"w", "W"}}, function(lst)
    local extendSpaces = lst[1] == "a"
    local nopunc = lst[2] == "w"
    return {exclusive = false, linewise = false}, (function(opts)
        -- Currently without repetition/extension
        opts.initialX = opts.initialX or opts.x
        opts.initialY = opts.initialY or opts.y
        local line = filelines[opts.y]
        local word, beg, ed = str.wordOfPos(line, opts.x, nopunc)
        if extendSpaces then
            local extLeft, extRight = 0, 0
            local _, len = line:sub(ed + 1):find("^[ \x09]+")
            if len then
                extRight = len
            else
                local matchBeg, matchEd = line:sub(1, beg - 1):find("[ \x09]+$")
                if matchBeg then
                    extLeft = matchEd - matchBeg + 1
                end
            end
            beg = beg - extLeft
            ed = ed + extRight
        end
        local backward = opts.y < opts.initialY or opts.y == opts.initialY and opts.x < opts.initialX
        if backward then
            if opts.x > beg then
                opts.x = beg
            end
            if opts.initialY == opts.y and opts.initialX < ed then
                opts.initialX = ed
            end
        else
            if opts.x < ed then
                opts.x = ed
            end
            if opts.initialY == opts.y and opts.initialX > beg then
                opts.initialX = beg
            end
        end
        return opts
    end)
end)
function afterDelete(settings)
            while currCursorY + currFileOffset > #filelines do
                currCursorY = currCursorY - 1
                if currCursorY < 1 then
                    while currCursorY < 1 do
                        currFileOffset = currFileOffset - 1
                        currCursorY = currCursorY + 1
                    end
                end
            end
            local lineLength = #filelines[currCursorY + currFileOffset]
            if settings.onePastEOL then
                lineLength = lineLength + 1
            end
            while currCursorX + currXOffset > lineLength do
                currCursorX = currCursorX - 1
                if currCursorX < 1 then
                    while currCursorX < 1 do
                        currXOffset = currXOffset - 1
                        currCursorX = currCursorX + 1
                    end
                end
            end
            recalcMLCs()
            drawFile(true)
        end
registerAction("D", function()
    resetLastSearch()
    cutTextObject(textObjectEOL())
end)
registerAction("p", function()
            lastSearchPos = nil
            lastSearchLine = nil
            if copytype == "line" then
                table.insert(filelines, currCursorY + currFileOffset + 1, copybuffer)
            elseif copytype == "text" then
                filelines[currCursorY + currFileOffset] = string.sub(filelines[currCursorY + currFileOffset], 1, currCursorX + currXOffset) .. copybuffer .. string.sub(filelines[currCursorY + currFileOffset], currCursorX + currXOffset + 1, #filelines[currCursorY + currFileOffset])
                currCursorX = currCursorX + #copybuffer --minus one so we can have the function reset viewpoint
                while currCursorX + lineoffset > wid do
                    currCursorX = currCursorX - 1
                    currXOffset = currXOffset + 1
                end
            elseif copytype == "linetable" then
                for i=#copybuffer,1,-1 do
                    table.insert(filelines, currCursorY + currFileOffset + 1, copybuffer[i])
                end
            elseif copytype == "texttable" then
                if #copybuffer > 0 then
                    local line = filelines[currCursorY + currFileOffset]
                    local prefix = line:sub(1, currCursorX + currXOffset)
                    local suffix = line:sub(currCursorX + currXOffset + 1, #line)
                    filelines[currCursorY + currFileOffset] = prefix .. copybuffer[1]
                    for i = #copybuffer, 2, -1 do
                        table.insert(filelines, currCursorY + currFileOffset + 1, copybuffer[i])
                    end
                    filelines[currCursorY + currFileOffset + #copybuffer - 1] = filelines[currCursorY + currFileOffset + #copybuffer - 1] .. suffix
                end
            end
            recalcMLCs(true)
            drawFile(true)
            if fileContents[currfile] then
                fileContents[currfile]["unsavedchanges"] = true
            end
        end)
registerAction("P", function()
            lastSearchPos = nil
            lastSearchLine = nil
            if copytype == "line" then
                table.insert(filelines, currCursorY + currFileOffset, copybuffer)
            elseif copytype == "text" then
                filelines[currCursorY + currFileOffset] = string.sub(filelines[currCursorY + currFileOffset], 1, currCursorX + currXOffset - 1) .. copybuffer .. string.sub(filelines[currCursorY + currFileOffset], currCursorX + currXOffset, #filelines[currCursorY + currFileOffset])
                currCursorX = currCursorX + #copybuffer
                while currCursorX + lineoffset > wid do
                    currCursorX = currCursorX - 1
                    currXOffset = currXOffset + 1
                end
            elseif copytype == "linetable" then
                for i=#copybuffer,1,-1 do
                    table.insert(filelines, currCursorY + currFileOffset, copybuffer[i])
                end
                currCursorY = currCursorY + #copybuffer
                while currCursorY > hig - 1 do
                    currCursorY = currCursorY - 1
                    currFileOffset = currFileOffset + 1
                end
            elseif copytype == "texttable" then
                if #copybuffer > 0 then
                    local line = filelines[currCursorY + currFileOffset]
                    local prefix = line:sub(1, currCursorX + currXOffset - 1)
                    local suffix = line:sub(currCursorX + currXOffset, #line)
                    filelines[currCursorY + currFileOffset] = copybuffer[#copybuffer] .. suffix
                    for i = #copybuffer - 1, 1, -1 do
                        table.insert(filelines, currCursorY + currFileOffset, copybuffer[i])
                    end
                    filelines[currCursorY + currFileOffset] = prefix .. filelines[currCursorY + currFileOffset]
                    currCursorY = currCursorY + #copybuffer - 1
                    if #copybuffer > 1 then
                        currCursorX = #copybuffer[#copybuffer] + 1 - currXOffset
                    else
                        currCursorX = currCursorX + #copybuffer[1]
                    end
                    scrollToCursor()
                end
            end
            recalcMLCs(true)
            drawFile(true)
            fileContents[currfile]["unsavedchanges"] = true
        end)
registerMotion("$", {exclusive = false}, textObjectEOL)
registerMotion("0", {exclusive = true}, function(opts)
    opts.wantX = nil
    opts.x = 1
    return opts
end)
registerAction("gJ", function() resetLastSearch()
                filelines[currCursorY + currFileOffset] = filelines[currCursorY + currFileOffset] .. filelines[currCursorY + currFileOffset + 1]
                table.remove(filelines, currCursorY + currFileOffset + 1)
                recalcMLCs()
                drawFile(true)
                fileContents[currfile]["unsavedchanges"] = true
            end)
registerMotion("gg", {}, function(opts)
    if opts.linewise == nil then  -- preserve false
        opts.linewise = true
    end
    opts.y = repeatCount1
    if opts.y > #filelines then
        opts.y = #filelines
    end
    local line = filelines[opts.y]
    opts.x = line:find("[^ \x09]") or #line
    if opts.x < 1 then
        opts.x = 1
    end
    opts.wantX = nil
    return opts
end)
registerMotionMulti({{"g"}, {"e", "E"}}, function(lst)
    local c = lst[2]
    return {exclusive = false}, (function(opts)
        local begs = str.wordEnds(filelines[opts.y], not string.match(c, "%u"))
        local begsSet = tab.itemIndices(begs)
        for i = 1, repeatCount1, 1 do
            if begs[#begs] and opts.x > begs[1] then
                opts.x = opts.x - 1
                while not begsSet[opts.x] do
                    opts.x = opts.x - 1
                end
                opts.wantX = opts.x
            else
                opts.x = 1
            end
        end
        return opts
    end)
end)
registerMotion("g_", {}, function(opts)
    local line = filelines[opts.y]
    local lastNonBlank = (line:find("[ \x09]*$") or #line + 1) - 1
    if lastNonBlank > 0 then
        opts.x = lastNonBlank
    else
        opts.x = 1
    end
end)
registerAction("gt", function()
    resetLastSearch()
    if repeatCount0 > 0 then
        switchToFile(repeatCount0)
    else
        switchToFile(currfile + 1)
    end
end)
registerAction("gT", function()
    resetLastSearch()
    switchToFile(currfile - 1)
end)
registerMotion("G", {}, function(opts)
    if opts.linewise == nil then  -- preserve false
        opts.linewise = true
    end
    if repeatCount0 > 0 then
        opts.y = repeatCount0
    else
        opts.y = #filelines
    end
    if opts.y > #filelines then
        opts.y = #filelines
    end
    local line = filelines[opts.y]
    opts.x = line:find("[^ \x09]") or #line
    if opts.x < 1 then
        opts.x = 1
    end
    opts.wantX = nil
    return opts
end)
registerMotionMulti({{"w", "W"}}, function(lst)
    local var1 = lst[1]
    return {exclusive = true}, (function(opts)
        local begs = str.wordBeginnings(filelines[opts.y], not string.match(var1, "%u"))
        local begsSet = tab.itemIndices(begs)
        for i = 1, repeatCount1, 1 do
            if begs[#begs] and opts.x < begs[#begs] then
                opts.x = opts.x + 1
                while not begsSet[opts.x] do
                    opts.x = opts.x + 1
                end
                opts.wantX = opts.x
            else
                opts.x = #filelines[opts.y] + 1  -- one past end, alternatively consider setting exclusive = false
            end
        end
        return opts
    end)
end)
registerMotionMulti({{"e", "E"}}, function(lst)
    local var1 = lst[1]
    return {exclusive = false}, (function(opts)
        local begs = str.wordEnds(filelines[opts.y], not string.match(var1, "%u"))
        local begsSet = tab.itemIndices(begs)
        for i = 1, repeatCount1, 1 do
            if begs[#begs] then
                if opts.x < begs[#begs] then
                    opts.x = opts.x + 1
                    while not begsSet[opts.x] do
                        opts.x = opts.x + 1
                    end
                    opts.wantX = opts.x
                end
            end
        end
        return opts
    end)
end)
registerMotionMulti({{"b", "B"}}, function(lst)
    local var1 = lst[1]
    return {exclusive = true}, (function (opts)
        local begs = str.wordBeginnings(filelines[opts.y], not string.match(var1, "%u"))
        local begsSet = tab.itemIndices(begs)
        for i = 1, repeatCount1, 1 do
            if begs[1] then
                if opts.x > begs[1] then
                    opts.x = opts.x - 1
                    while not begsSet[opts.x] do
                        opts.x = opts.x - 1
                    end
                    opts.wantX = opts.x
                end
            end
        end
        return opts
    end)
end)
registerMotion("^", {exclusive = true}, function(opts)
    return textObjectSOL(opts)
end)
local function textObjectCharacterFind(var1, c, opts)
    if var1 == "f" or var1 == "t" then
        local idx = str.indicesOfLetter(filelines[opts.y], c)
        local idxSet = tab.itemIndices(idx)
        for i = 1, repeatCount1, 1 do
            if #idx > 0 then
                if opts.x < idx[#idx] - jumpoffset then
                    local oldcursor = opts.x
                    opts.x = opts.x + (1 + jumpoffset)
                    opts.wantX = nil
                    while not idxSet[opts.x] and opts.x < #filelines[opts.y] do
                        opts.x = opts.x + 1
                    end
                    if not idxSet[opts.x] then
                        opts.x = oldcursor
                    end
                    if var1 == "t" then
                        opts.x = opts.x - 1
                    end
                    if var1 == "t" then
                        jumpoffset = 1
                    else
                        jumpoffset = 0
                    end
                end
            end
        end
    elseif var1 == "F" or var1 == "T" then
        local idx = str.indicesOfLetter(filelines[opts.y], c)
        local idxSet = tab.itemIndices(idx)
        for i = 1, repeatCount1, 1 do
            if #idx > 0 then
                if opts.x > idx[1] + jumpoffset then
                    opts.x = opts.x - (1 + jumpoffset)
                    opts.wantX = nil
                    while not idxSet[opts.x] and opts.x > 1 do
                        opts.x = opts.x - 1
                    end
                    if var1 == "T" then
                        opts.x = opts.x + 1
                    end
                    if var1 == "T" then
                        jumpoffset = 1
                    else
                        jumpoffset = 0
                    end
                end
            end
        end
    end
    return opts
end
registerMotionMulti({{"f", "t", "F", "T"}}, function(lst)
    local var1 = lst[1]
    return {exclusive = var1 == "F" or var1 == "T"}, (function (opts)
        local c = pullTypeaheadCharMode("i")
        jumpbuffer = {var1, c}
        return textObjectCharacterFind(var1, c, opts)
    end)
end)
registerMotion(";", {}, function(opts)
    local kind = jumpbuffer[1]
    if kind == "f" or kind == "t" or kind == "F" or kind == "T" then
        return textObjectCharacterFind(kind, jumpbuffer[2], opts)
    end
    return opts
end)
registerMotion(",", {}, function(opts)
    local kind = jumpbuffer[1]
    if kind == nil then
        return opts
    end
    kind = ({f = "F", t = "T", F = "f", T = "t"})[kind]
    if kind then
        return textObjectCharacterFind(kind, jumpbuffer[2], opts)
    end
    return opts
end)
--[[ FIXME why does it have a second implementation?
registerActionMulti({{"F", "T"}}, function(lst)
    local var1 = lst[1]
    return (function ()
            lastSearchPos = nil
            lastSearchLine = nil
            if jumpbuffer[1] then
                local tx = jumpbuffer[1]
                if var1 == "," then
                    if string.match(tx, "%u") then
                        tx = string.lower(tx)
                    else
                        tx = string.upper(tx)
                    end
                end
                if string.match(tx, "%u") then
                    local c = jumpbuffer[2]
                    local idx = str.indicesOfLetter(filelines[currCursorY + currFileOffset], c)
                    if #idx > 0 then
                        if currCursorX + currFileOffset > idx[1] + jumpoffset then
                            currCursorX = currCursorX - (1 + jumpoffset)
                            while not tab.find(idx, currCursorX + currXOffset) do
                                currCursorX = currCursorX - 1
                            end
                            if jumpbuffer[1] == "T" or jumpbuffer[1] == "t" then
                                currCursorX = currCursorX + 1
                            end
                            while currCursorX < 1 do
                                currCursorX = currCursorX + 1
                                currXOffset = currXOffset - 1
                            end
                            drawFile()
                        end
                    end
                else
                    local c = jumpbuffer[2]
                    local idx = str.indicesOfLetter(filelines[currCursorY + currFileOffset], c)
                    if #idx > 0 then
                        if currCursorX + currFileOffset < idx[#idx] - jumpoffset then
                            local oldcursor = currCursorX
                            currCursorX = currCursorX + (1 + jumpoffset)
                            while not tab.find(idx, currCursorX + currXOffset) and currCursorX + currXOffset ~= #filelines[currCursorY + currFileOffset] do
                                currCursorX = currCursorX + 1
                            end
                            if not tab.find(idx, currCursorX + currXOffset) then
                                currCursorX = oldcursor
                            end
                            if jumpbuffer[1] == "t" or jumpbuffer[1] == "T" then
                                currCursorX = currCursorX - 1
                            end
                            while currCursorX + lineoffset > wid do
                                currCursorX = currCursorX - 1
                                currXOffset = currXOffset + 1
                            end
                            drawFile()
                        end
                    end
                end
            end
        end)
    end)
]]
registerAction("cc", function()
    resetLastSearch()
    if cutTextObject(textObjectLine(), {addLine = true, onePastEOL = true}) then
        insertMode()
    end
end)
registerAction("c", function()
    resetLastSearch()
    local to = pullTextObject()
    if to == nil then
        sendMsg("No text object")
        return
    end
    if cutTextObject(to, {addLine = true, onePastEOL = true}) then
        insertMode()
    end
end)
registerVisualAction("c", function()
    resetLastSearch()
    if cutTextObject(visualModeState, {addLine = true, onePastEOL = true}) then
        visualSelectionRendered = false
        insertMode()
    end
    return true
end)
registerAction("C", function()
    resetLastSearch()
    if cutTextObject(textObjectEOL(), {onePastEOL = true}) then
        insertMode()
    end
end)
registerAction("s", function()
            filelines[currCursorY + currFileOffset] = string.sub(filelines[currCursorY + currFileOffset], 1, currCursorX + currXOffset - 1) .. string.sub(filelines[currCursorY + currFileOffset], currCursorX + currXOffset + 1, #filelines[currCursorY + currFileOffset])
            recalcMLCs()
            drawFile()
            if not fileContents[currfile] then
                fileContents[currfile] = {""}
            end
            fileContents[currfile]["unsavedchanges"] = true
            insertMode()
        end)
registerAction("S", function()
            lastSearchPos = nil
            lastSearchLine = nil
            filelines[currCursorY + currFileOffset] = ""
            currCursorX = 1
            currXOffset = 0
            recalcMLCs()
            drawFile()
            fileContents[currfile]["unsavedchanges"] = true
            insertMode()
        end)
registerMotion("%", {exclusive = false}, function(opts)
    local startpos = {opts.x, opts.y}
    local startbracket = string.sub(filelines[opts.y], opts.x, opts.x)
    local endbracket = ""
    if startbracket == "(" then
        endbracket = ")"
    elseif startbracket == "{" then
        endbracket = "}"
    elseif startbracket == "[" then
        endbracket = "]"
    else
        endbracket = nil
    end
    if endbracket then
        local extrabrackets = 0
        local continuefor = true
        opts.x = opts.x + 1
        for i = opts.y, #filelines, 1 do
            if continuefor then
                while opts.x <= #filelines[opts.y] do
                    if string.sub(filelines[opts.y], opts.x, opts.x) == startbracket then
                        extrabrackets = extrabrackets + 1
                    elseif string.sub(filelines[opts.y], opts.x, opts.x) == endbracket then
                        if extrabrackets > 0 then
                            extrabrackets = extrabrackets - 1
                        else
                            extrabrackets = extrabrackets - 1
                        end
                    end
                    opts.x = opts.x + 1
                end
                if (string.sub(filelines[opts.y], opts.x, opts.x) == endbracket and extrabrackets == 0) or extrabrackets < 0 then
                    if opts.x > 1 then
                        opts.x = opts.x - 1
                    end
                    continuefor = false
                else
                    opts.x = 1
                    if #filelines > 1 then
                        opts.y = opts.y + 1
                    end
                end
            end
        end
    end
    if not string.sub(filelines[opts.y], opts.x, opts.x) == endbracket then
        opts.x = startpos[1]
        opts.y = startpos[2]
    end
end)
registerAction("/", function()
            search("forward")
        end)
registerAction("?", function()
            search("backward")
        end)
registerAction("n", function()
            search("forward", true)
        end)
registerAction("N", function()
            search("backward", true)
        end)
registerAction("*", function()
            local currword = str.wordOfPos(filelines[currCursorY + currFileOffset], currCursorX + currXOffset, true)
            search("forward", false, currword)
        end)
registerAction("#", function()
            local currword = str.wordOfPos(filelines[currCursorY + currFileOffset], currCursorX + currXOffset, true)
            search("backward", false, currword)
        end)

registerNormalVisualAction("<C-u>", function()
    if repeatCount0 > 0 then
        scrollOption = repeatCount0
    end
    scrollWindowY(-scrollOption, true)
end)
registerNormalVisualAction("<C-d>", function()
    if repeatCount0 > 0 then
        scrollOption = repeatCount0
    end
    scrollWindowY(scrollOption, true)
end)
registerNormalVisualAction("<C-b>", function()
    local multiplier = hig - 3
    if multiplier < 1 then
        multiplier = 1
    end
    local amount = multiplier * repeatCount1 + 2
    scrollWindowY(-amount, false)
end)
registerNormalVisualAction("<C-f>", function()
    local multiplier = hig - 3
    if multiplier < 1 then
        multiplier = 1
    end
    local amount = multiplier * repeatCount1 + 2
    scrollWindowY(amount, false)
end)
registerNormalVisualAction("<C-y>", function()
    scrollWindowY(-repeatCount1, false)
end)
registerNormalVisualAction("<C-e>", function()
    scrollWindowY(repeatCount1, false)
end)
registerNormalVisualAction("<scrollwheelup>", function()
    scrollWindowY(-repeatCount1 * 3, false)
end)
registerNormalVisualAction("<scrollwheeldown>", function()
    scrollWindowY(repeatCount1 * 3, false)
end)
registerNormalVisualAction("<S-scrollwheelup>", function()
    local multiplier = hig - 3
    if multiplier < 1 then
        multiplier = 1
    end
    local amount = multiplier * repeatCount1 + 2
    scrollWindowY(-amount, false)
end)
registerNormalVisualAction("<S-scrollwheeldown>", function()
    local multiplier = hig - 3
    if multiplier < 1 then
        multiplier = 1
    end
    local amount = multiplier * repeatCount1 + 2
    scrollWindowY(amount, false)
end)
registerNormalVisualAction("<pageup>", function()
    local multiplier = hig - 3
    if multiplier < 1 then
        multiplier = 1
    end
    local amount = multiplier * repeatCount1 + 2
    scrollWindowY(-amount, false)
end)
registerNormalVisualAction("<pagedown>", function()
    local multiplier = hig - 3
    if multiplier < 1 then
        multiplier = 1
    end
    local amount = multiplier * repeatCount1 + 2
    scrollWindowY(amount, false)
end)

registerMotion("<leftmouse>", {exclusive = true}, function(opts)
    opts.x = inputProperties.mouseX + currXOffset - lineoffset
    opts.y = inputProperties.mouseY + currFileOffset
    if opts.y > #filelines then
        opts.y = #filelines
    end
    local line = filelines[opts.y]
    opts.wantX = opts.x
    if line and #line < opts.x then
        opts.x = #line
    end
end)

registerAction(">>", function()
    resetLastSearch()
    oldx = nil
    local singleShiftBuilder = {}
    for i = 1, getShiftWidth() do
        singleShiftBuilder[i] = " "
    end
    local singleShift = table.concat(singleShiftBuilder)
    local repeatedShiftBuilder = {}
    for i = 1, repeatCount1 do
        repeatedShiftBuilder[i] = singleShift
    end
    local repeatedShift = table.concat(repeatedShiftBuilder)
    local line = filelines[currCursorY + currFileOffset]
    filelines[currCursorY + currFileOffset] = repeatedShift .. line
    currCursorX = currCursorX + #repeatedShift
    if currCursorX + lineoffset > wid then
        local delta = wid - currCursorX - lineoffset
        currCursorX = currCursorX + delta
        currXOffset = currXOffset - delta
    end
    recalcMLCs()
    fileContents[currfile]["unsavedchanges"] = true
    drawFile()
end)
registerAction("<lt><lt>", function()
    resetLastSearch()
    oldx = nil
    local amount = getShiftWidth() * repeatCount1
    local line = filelines[currCursorY + currFileOffset]
    local firstNonBlank = line:find("[^ \x09]") or #line + 1
    if amount >= firstNonBlank then
        amount = firstNonBlank - 1
    end
    filelines[currCursorY + currFileOffset] = line:sub(amount + 1)
    currCursorX = currCursorX - amount
    if currCursorX < 1 then
        currXOffset = currXOffset + currCursorX - 1
        currCursorX = 1
        if currXOffset < 0 then
            currXOffset = 0
        end
    end
    recalcMLCs()
    fileContents[currfile]["unsavedchanges"] = true
    drawFile()
end)

-- By default paste content is interpreted as normal-mode keys, use mappings to change this behavior
registerAction("<C-S-v>", function()
    expandPaste()
end)

registerVisualAction("v", function()
    if visualModeState.linewise then
        visualModeState.linewise = false
        return false
    else
        return true
    end
end)

registerVisualAction("V", function()
    if not visualModeState.linewise then
        visualModeState.linewise = true
        return false
    else
        return true
    end
end)

registerVisualAction("v", function()
    if visualModeState.linewise then
        visualModeState.linewise = false
        return false
    else
        return true
    end
end)

registerAction("gv", function()
    visualMode()
end)

registerAction("v", function()
    visualModeState = {linewise = false}
    visualMode()
end)

registerAction("V", function()
    visualModeState = {linewise = true}
    visualMode()
end)

registerVisualAction("o", function()
    visualModeState.x, visualModeState.initialX = visualModeState.initialX, visualModeState.x
    visualModeState.y, visualModeState.initialY = visualModeState.initialY, visualModeState.y
    return false
end)

registerVisualAction("O", function()
    visualModeState.x, visualModeState.initialX = visualModeState.initialX, visualModeState.x
    return false
end)

function normalModeSingle()
    local prevMode = currentMode
    currentMode = "n"
    local prio = {action = 2, motion = 1, max = 2}
    local cons = Trie.Consumer.new{
        n = prio.max,
        [prio.action] = actionsTrie,
        [prio.motion] = motionsTrie,
    }
    local i = 0
    local prefix = {}
    local countStr = pullCount()
    if #countStr > 0 then
        repeatCount0 = tonumber(countStr)
        repeatCount1 = repeatCount0
    else
        repeatCount0 = 0
        repeatCount1 = 1
    end
    while true do
        i = i + 1
        local key
        if i == 1 then
            key = peekTypeaheadWRMP(i)
        else
            key = peekTypeahead(i)
        end
        if key == "C-c" then
            -- Clear typeahead
            for _ = 1, i do
                pullTypeahead()
            end
            cons = nil
            break
        end
        prefix[i] = key
        if not cons:next(key) then
            break
        end
        if not cons:hasNext() then
            break
        end
    end
    if cons ~= nil then
        local len, action, kind = cons:getDeepest()
        if len > 0 then
            for _ = 1, len do
                pullTypeahead()
            end
            if kind == prio.action then
                action()
            elseif kind == prio.motion then
                performMotion(action[0], action[1])
            end
            currentMode = prevMode
            return true
        else
            -- Drop one key
            pullTypeahead()
            currentMode = prevMode
            return false
        end
    else
        currentMode = prevMode
        return false
    end
end

while running == true do
    normalModeSingle()
end