diff --git a/vimfiles/GetLatest/GetLatestVimScripts.dat b/vimfiles/GetLatest/GetLatestVimScripts.dat
index a863f5b..29cc84b 100644
--- a/vimfiles/GetLatest/GetLatestVimScripts.dat
+++ b/vimfiles/GetLatest/GetLatestVimScripts.dat
@@ -39,3 +39,4 @@ ScriptID SourceID Filename
 2830 22798 csv.vim
 3849 22637 git-time-lapse
 4932 22787 diffchar.vim
+4955 22442 Merginal
diff --git a/vimfiles/autoload/merginal.vim b/vimfiles/autoload/merginal.vim
new file mode 100755
index 0000000..1ebc5c0
--- /dev/null
+++ b/vimfiles/autoload/merginal.vim
@@ -0,0 +1,1052 @@
+"Use vimproc if available under windows to prevent opening a console window
+function! merginal#system(command,...)
+    if has('win32') && exists(':VimProcBang') "We don't need vimproc when we use linux
+        if empty(a:000)
+            return vimproc#system(a:command)
+        else
+            return vimproc#system(a:command,a:000[0])
+        endif
+    else
+        if empty(a:000)
+            return system(a:command)
+        else
+            return system(a:command,a:000[0])
+        endif
+    endif
+endfunction
+
+"Opens a file that belongs to a repo in a window that already belongs to that
+"repo. Creates a new window if can't find suitable window.
+function! merginal#openFileDecidedWindow(repo,fileName)
+    "We have to check with bufexists, because bufnr also match prefixes of the
+    "file name
+    let l:fileBuffer=-1
+    if bufexists(a:fileName)
+        let l:fileBuffer=bufnr(a:fileName)
+    endif
+
+    "We have to check with bufloaded, because bufwinnr also matches closed
+    "windows...
+    let l:windowToOpenIn=-1
+    if bufloaded(l:fileBuffer)
+        let l:windowToOpenIn=bufwinnr(l:fileBuffer)
+    endif
+
+    "If we found an open window with the correct file, we jump to it
+    if -1<l:windowToOpenIn
+        execute l:windowToOpenIn.'wincmd w'
+    else
+        "Check if the previous window can be used
+        let l:previousWindow=winnr('#')
+        if s:isWindowADisposableWindowOfRepo(l:previousWindow,a:repo)
+            execute winnr('#').'wincmd w'
+        else
+            "If the previous window can't be used, check if any open
+            "window can be used
+            let l:windowsToOpenTheFileIn=merginal#getListOfDisposableWindowsOfRepo(a:repo)
+            if empty(l:windowsToOpenTheFileIn)
+                "If no open window can be used, open a new Vim window
+                new
+            else
+                execute l:windowsToOpenTheFileIn[0].'wincmd w'
+            endif
+        endif
+        if -1<l:fileBuffer
+            "If the buffer is already open, jump to it
+            execute 'buffer '.l:fileBuffer
+        else
+            "Otherwise, load it
+            execute 'edit '.fnameescape(a:fileName)
+        endif
+    endif
+    diffoff "Just in case...
+endfunction
+
+"Check if the current window is modifiable, saved, and belongs to the repo
+function! s:isCurrentWindowADisposableWindowOfRepo(repo)
+    if !&modifiable
+        return 0
+    endif
+    if &modified
+        return 0
+    endif
+    try
+        return a:repo==fugitive#repo()
+    catch
+        return 0
+    endtry
+endfunction
+
+"Calls s:isCurrentWindowADisposableWindowOfRepo with a window number
+function! s:isWindowADisposableWindowOfRepo(winnr,repo)
+    let l:currentWindow=winnr()
+    try
+        execute a:winnr.'wincmd w'
+        return s:isCurrentWindowADisposableWindowOfRepo(a:repo)
+    finally
+        execute l:currentWindow.'wincmd w'
+    endtry
+endfunction
+
+"Get a list of windows that yield true with s:isWindowADisposableWindowOfRepo
+function! merginal#getListOfDisposableWindowsOfRepo(repo)
+    let l:result=[]
+    let l:currentWindow=winnr()
+    windo if s:isCurrentWindowADisposableWindowOfRepo(a:repo) | call add(l:result,winnr()) |  endif
+    execute l:currentWindow.'wincmd w'
+    return l:result
+endfunction
+
+"Get the repository that belongs to a window
+function! s:getRepoOfWindow(winnr)
+    "Ignore bad window numbers
+    if a:winnr<=0
+        return {}
+    endif
+    let l:currentWindow=winnr()
+    try
+        execute a:winnr.'wincmd w'
+        return fugitive#repo()
+    catch
+        return {}
+    finally
+        execute l:currentWindow.'wincmd w'
+    endtry
+endfunction
+
+"Reload the buffers
+function! merginal#reloadBuffers()
+    let l:currentWindow=winnr()
+    try
+        silent windo if ''==&buftype
+                    \| edit
+                    \| endif
+    catch
+        "do nothing
+    endtry
+    execute l:currentWindow.'wincmd w'
+endfunction
+
+"Exactly what it says on tin
+function! merginal#runGitCommandInTreeReturnResult(repo,command)
+    let l:dir=getcwd()
+    execute 'cd '.fnameescape(a:repo.tree())
+    try
+        return merginal#system(a:repo.git_command().' '.a:command)
+    finally
+        execute 'cd '.fnameescape(l:dir)
+    endtry
+endfunction
+
+"Like merginal#runGitCommandInTreeReturnResult but split result to lines
+function! merginal#runGitCommandInTreeReturnResultLines(repo,command)
+    let l:dir=getcwd()
+    execute 'cd '.fnameescape(a:repo.tree())
+    try
+        return split(merginal#system(a:repo.git_command().' '.a:command),'\r\n\|\n\|\r')
+    finally
+        execute 'cd '.fnameescape(l:dir)
+    endtry
+endfunction
+
+"Returns 1 if there was a merginal bufffer to close
+function! merginal#closeMerginalBuffer()
+    let l:merginalWindowNumber=bufwinnr('Merginal:')
+    if 0<=l:merginalWindowNumber
+        let l:currentWindow=winnr()
+        try
+            execute l:merginalWindowNumber.'wincmd w'
+            wincmd q
+            "If the current window is after the merginal window, closing the
+            "merginal window will decrease the current window's nubmer.
+            if l:merginalWindowNumber<l:currentWindow
+                let l:currentWindow=l:currentWindow-1
+            endif
+            return 1
+        finally
+            execute l:currentWindow.'wincmd w'
+        endtry
+    end
+    return 0
+endfunction
+
+"Returns 1 if a new buffer was opened, 0 if it already existed
+function! merginal#openTuiBuffer(bufferName,inWindow)
+    let l:repo=fugitive#repo()
+
+    let l:tuiBufferWindow=bufwinnr(bufnr(a:bufferName))
+
+    if -1<l:tuiBufferWindow "Jump to the already open buffer
+        execute l:tuiBufferWindow.'wincmd w'
+    else "Open a new buffer
+        if merginal#isMerginalWindow(a:inWindow)
+            execute a:inWindow.'wincmd w'
+            enew
+        else
+            40vnew
+        endif
+        setlocal buftype=nofile
+        setlocal bufhidden=wipe
+        setlocal nomodifiable
+        setlocal winfixwidth
+        setlocal winfixheight
+        setlocal nonumber
+        setlocal norelativenumber
+        execute 'silent file '.a:bufferName
+        call fugitive#detect(l:repo.dir())
+    endif
+
+    "At any rate, reassign the active repository
+    let b:merginal_repo=l:repo
+    let b:headerLinesCount=0
+
+    "Check and return if a new buffer was created
+    return -1==l:tuiBufferWindow
+endfunction
+
+
+"Check if a window belongs to Merginal
+function! merginal#isMerginalWindow(winnr)
+    if a:winnr<=0
+        return 0
+    endif
+    let l:buffer=winbufnr(a:winnr)
+    if l:buffer<=0
+        return 0
+    endif
+    "check for the merginal repo buffer variable
+    return !empty(getbufvar(l:buffer,'merginal_repo'))
+endfunction
+
+
+"For the branch in the specified line, retrieve:
+" - type: 'local', 'remote' or 'detached'
+" - isCurrent, isLocal, isRemote, isDetached
+" - remote: the name of the remote or '' for local branches
+" - name: the name of the branch, without the remote
+" - handle: the named used for referring the branch in git commands
+function! merginal#branchDetails(lineNumber)
+    if !exists('b:merginal_repo')
+        throw 'Unable to get branch details outside the merginal window'
+    endif
+    if line(a:lineNumber)<=b:headerLinesCount
+        throw 'Unable to get branch details for the header of the merginal window'
+    endif
+    let l:line=getline(a:lineNumber)
+    let l:result={}
+
+
+    "Check if this branch is the currently selected one
+    let l:result.isCurrent=('*'==l:line[0])
+    let l:line=l:line[2:]
+
+    let l:detachedMatch=matchlist(l:line,'\v^\(detached from ([^/]+)%(/(.*))?\)$')
+    if !empty(l:detachedMatch)
+        let l:result.type='detached'
+        let l:result.isLocal=0
+        let l:result.isRemote=0
+        let l:result.isDetached=1
+        let l:result.remote=l:detachedMatch[1]
+        let l:result.name=l:detachedMatch[2]
+        if empty(l:detachedMatch[2])
+            let l:result.handle=l:detachedMatch[1]
+        else
+            let l:result.handle=l:detachedMatch[1].'/'.l:detachedMatch[2]
+        endif
+        return l:result
+    endif
+
+    let l:remoteMatch=matchlist(l:line,'\v^remotes/([^/]+)%(/(\S*))%( \-\> (\S+))?$')
+    if !empty(l:remoteMatch)
+        let l:result.type='remote'
+        let l:result.isLocal=0
+        let l:result.isRemote=1
+        let l:result.isDetached=0
+        let l:result.remote=l:remoteMatch[1]
+        let l:result.name=l:remoteMatch[2]
+        if empty(l:remoteMatch[2])
+            let l:result.handle=l:remoteMatch[1]
+        else
+            let l:result.handle=l:remoteMatch[1].'/'.l:remoteMatch[2]
+        endif
+        return l:result
+    endif
+
+    let l:result.type='local'
+    let l:result.isLocal=1
+    let l:result.isRemote=0
+    let l:result.isDetached=0
+    let l:result.remote=''
+    let l:result.name=l:line
+    let l:result.handle=l:line
+
+    return l:result
+endfunction
+
+"For the file in the specified line, retrieve:
+" - name: the name of the file
+function! merginal#fileDetails(lineNumber)
+    if !exists('b:merginal_repo')
+        throw 'Unable to get file details outside the merginal window'
+    endif
+    if line(a:lineNumber)<=b:headerLinesCount
+        throw 'Unable to get branch details for the header of the merginal window'
+    endif
+    let l:line=getline(a:lineNumber)
+    let l:result={}
+
+    let l:result.name=l:line
+
+    return l:result
+endfunction
+
+function! merginal#getLocalBranchNamesThatTrackARemoteBranch(remoteBranchName)
+    "Get verbose list of branches
+    let l:branchList=split(merginal#system(b:merginal_repo.git_command('branch','-vv')),'\r\n\|\n\|\r')
+
+    "Filter for branches that track our remote
+    let l:checkIfTrackingRegex='\V['.escape(a:remoteBranchName,'\').'\[\]:]'
+    let l:branchList=filter(l:branchList,'v:val=~l:checkIfTrackingRegex')
+
+    "Extract the branch name from the matching lines
+    "let l:extractBranchNameRegex='\v^\*?\s*(\S+)'
+    "let l:branchList=map(l:branchList,'matchlist(v:val,l:extractBranchNameRegex)[1]')
+    let l:extractBranchNameRegex='\v^\*?\s*\zs\S+'
+    let l:branchList=map(l:branchList,'matchstr(v:val,l:extractBranchNameRegex)')
+
+    return l:branchList
+endfunction
+
+function! merginal#getRemoteBranchTrackedByLocalBranch(localBranchName)
+    let l:result=merginal#system(b:merginal_repo.git_command('branch','--list',a:localBranchName,'-vv'))
+    echo l:result
+    return matchstr(l:result,'\v\[\zs[^\[\]:]*\ze[\]:]')
+endfunction
+
+
+"Check if the current buffer's repo is in rebase mode
+function! merginal#isRebaseMode()
+    return isdirectory(fugitive#repo().dir('rebase-apply'))
+endfunction
+
+"Check if the current buffer's repo is in rebase amend mode
+function! merginal#isRebaseAmendMode()
+    return isdirectory(fugitive#repo().dir('rebase-merge'))
+endfunction
+
+"Check if the current buffer's repo is in merge mode
+function! merginal#isMergeMode()
+    "Use glob() to check for file existence
+    return !empty(glob(fugitive#repo().dir('MERGE_MODE')))
+endfunction
+
+"Open the branch list buffer for controlling buffers
+function! merginal#openBranchListBuffer(...)
+    if merginal#openTuiBuffer('Merginal:Branches',get(a:000,1,bufwinnr('Merginal:')))
+        doautocmd User Merginal_BranchList
+    endif
+
+    "At any rate, refresh the buffer:
+    call merginal#tryRefreshBranchListBuffer(1)
+endfunction
+
+augroup merginal
+    autocmd User Merginal_BranchList nnoremap <buffer> R :call merginal#tryRefreshBranchListBuffer(0)<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> C :call <SID>checkoutBranchUnderCursor()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> cc :call <SID>checkoutBranchUnderCursor()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> ct :call <SID>trackBranchUnderCursor(0)<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> cT :call <SID>trackBranchUnderCursor(1)<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> A :call <SID>promptToCreateNewBranch()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> aa :call <SID>promptToCreateNewBranch()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> D :call <SID>deleteBranchUnderCursor()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> dd :call <SID>deleteBranchUnderCursor()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> M :call <SID>mergeBranchUnderCursor()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> mm :call <SID>mergeBranchUnderCursor()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> mf :call <SID>mergeBranchUnderCursorUsingFugitive()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> rb :call <SID>rebaseBranchUnderCursor()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> ps :call <SID>remoteActionForBranchUnderCursor('push',0)<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> pS :call <SID>remoteActionForBranchUnderCursor('push',1)<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> pl :call <SID>remoteActionForBranchUnderCursor('pull',0)<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> pf :call <SID>remoteActionForBranchUnderCursor('fetch',0)<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> gd :call <SID>diffWithBranchUnderCursor()<Cr>
+    autocmd User Merginal_BranchList nnoremap <buffer> rn :call <SID>renameBranchUnderCursor()<Cr>
+augroup END
+
+"If the current buffer is a branch list buffer - refresh it!
+function! merginal#tryRefreshBranchListBuffer(jumpToCurrentBranch)
+    if 'Merginal:Branches'==bufname('')
+        let l:branchList=split(merginal#system(b:merginal_repo.git_command('branch','--all')),'\r\n\|\n\|\r')
+        let l:currentLine=line('.')
+
+        setlocal modifiable
+        "Clear the buffer:
+        normal ggdG
+        "Write the branch list:
+        call setline(1,l:branchList)
+        setlocal nomodifiable
+
+
+        if a:jumpToCurrentBranch
+            "Find the current branch's index
+            let l:currentBranchIndex=-1
+            for i in range(len(l:branchList))
+                if '*'==l:branchList[i][0]
+                    let l:currentBranchIndex=i
+                    break
+                endif
+            endfor
+            if -1<l:currentBranchIndex
+                "Jump to the current branch's line
+                execute l:currentBranchIndex+1
+            endif
+        else
+            execute l:currentLine
+        endif
+    endif
+endfunction
+
+"Exactly what it says on tin
+function! s:checkoutBranchUnderCursor()
+    if 'Merginal:Branches'==bufname('')
+        let l:branch=merginal#branchDetails('.')
+        echo merginal#runGitCommandInTreeReturnResult(b:merginal_repo,'--no-pager checkout '.shellescape(l:branch.handle))
+        call merginal#reloadBuffers()
+        call merginal#tryRefreshBranchListBuffer(0)
+    endif
+endfunction
+
+"Track what it says on tin
+function! s:trackBranchUnderCursor(promptForName)
+    if 'Merginal:Branches'==bufname('')
+        let l:branch=merginal#branchDetails('.')
+        if !l:branch.isRemote
+            throw 'Can not track - branch is not remote'
+        endif
+        let l:newBranchName=l:branch.name
+        if a:promptForName
+            let l:newBranchName=input('Track `'.l:branch.handle.'` as: ',l:newBranchName)
+            if empty(l:newBranchName)
+                echo ' '
+                echo 'Branch tracking canceled by the user'
+                return
+            endif
+        endif
+        echo merginal#runGitCommandInTreeReturnResult(b:merginal_repo,'--no-pager checkout -b '.shellescape(l:newBranchName).' --track '.shellescape(l:branch.handle))
+        call merginal#reloadBuffers()
+        call merginal#tryRefreshBranchListBuffer(0)
+    endif
+endfunction
+
+"Uses the current branch as the source
+function! s:promptToCreateNewBranch()
+    if 'Merginal:Branches'==bufname('')
+        let l:newBranchName=input('Branch `'.b:merginal_repo.head().'` to: ')
+            if empty(l:newBranchName)
+                echo ' '
+                echo 'Branch creation canceled by the user'
+                return
+            endif
+        echo merginal#runGitCommandInTreeReturnResult(b:merginal_repo,'--no-pager checkout -b '.shellescape(l:newBranchName))
+        call merginal#reloadBuffers()
+        call merginal#tryRefreshBranchListBuffer(1)
+    endif
+endfunction
+
+"Verifies the decision
+function! s:deleteBranchUnderCursor()
+    if 'Merginal:Branches'==bufname('')
+        let l:branch=merginal#branchDetails('.')
+        let l:answer=0
+        if l:branch.isLocal
+            let l:answer='yes'==input('Delete branch `'.l:branch.handle.'`?(type "yes" to confirm) ')
+        elseif l:branch.isRemote
+            "Deleting remote branches needs a special warning
+            let l:answer='yes-remote'==input('Delete remote(!) branch `'.l:branch.handle.'`?(type "yes-remote" to confirm) ')
+        endif
+        if l:answer
+            if l:branch.isLocal
+                echo ' '
+                echo merginal#runGitCommandInTreeReturnResult(b:merginal_repo,'--no-pager branch -D '.shellescape(l:branch.handle))
+            else
+                execute '!'.b:merginal_repo.git_command('push').' '.shellescape(l:branch.remote).' --delete '.shellescape(l:branch.name)
+            endif
+            call merginal#reloadBuffers()
+            call merginal#tryRefreshBranchListBuffer(0)
+        else
+            echo ' '
+            echo 'Branch deletion canceled by the user'
+        endif
+    endif
+endfunction
+
+"If there are merge conflicts, opens the merge conflicts buffer
+function! s:mergeBranchUnderCursor()
+    if 'Merginal:Branches'==bufname('')
+        let l:branch=merginal#branchDetails('.')
+        echo ' '
+        echo merginal#runGitCommandInTreeReturnResult(b:merginal_repo,'merge --no-commit '.shellescape(l:branch.handle))
+        call merginal#reloadBuffers()
+        if v:shell_error
+            call merginal#openMergeConflictsBuffer(winnr())
+        elseif merginal#isMergeMode()
+            "If we are in merge mode without a shell error, that means there
+            "are not conflicts and the user can be prompted to enter a merge
+            "message.
+            Gstatus
+            call merginal#closeMerginalBuffer()
+        endif
+    endif
+endfunction
+
+"Use Fugitive's :Gmerge. It was added to Fugitive after I implemented
+"Merginal's merge, and I don't want to remove it since it can still more
+"comfortable for some.
+function! s:mergeBranchUnderCursorUsingFugitive()
+    if 'Merginal:Branches'==bufname('')
+        let l:branch=merginal#branchDetails('.')
+        execute ':Gmerge '.l:branchName.handle
+    endif
+endfunction
+
+"If there are rebase conflicts, opens the rebase conflicts buffer
+function! s:rebaseBranchUnderCursor()
+    if 'Merginal:Branches'==bufname('')
+        let l:branch=merginal#branchDetails('.')
+        echo ' '
+        echo merginal#runGitCommandInTreeReturnResult(b:merginal_repo,'rebase '.shellescape(l:branch.handle))
+        call merginal#reloadBuffers()
+        if v:shell_error
+            call merginal#openRebaseConflictsBuffer(winnr())
+        endif
+    endif
+endfunction
+
+"Run various remote actions
+function! s:remoteActionForBranchUnderCursor(remoteAction,force)
+    if 'Merginal:Branches'==bufname('')
+        let l:branch=merginal#branchDetails('.')
+        if l:branch.isLocal
+            let l:remotes=merginal#runGitCommandInTreeReturnResultLines(b:merginal_repo,'remote')
+            if empty(l:remotes)
+                throw 'Can not '.a:remoteAction.' - no remotes defined'
+            endif
+
+            let l:chosenRemoteIndex=0
+            if 1<len(l:remotes)
+                let l:listForInputlist=map(copy(l:remotes),'v:key+1.") ".v:val')
+                "Choose the correct text accoring to the action:
+                if 'push'==a:remoteAction
+                    call insert(l:listForInputlist,'Choose remote to '.a:remoteAction.' `'.l:branch.handle.'` to:')
+                else
+                    call insert(l:listForInputlist,'Choose remote to '.a:remoteAction.' `'.l:branch.handle.'` from:')
+                endif
+                let l:chosenRemoteIndex=inputlist(l:listForInputlist)
+
+                "Check that the chosen index is in range
+                if l:chosenRemoteIndex<=0 || len(l:remotes)<l:chosenRemoteIndex
+                    return
+                endif
+
+                let l:chosenRemoteIndex=l:chosenRemoteIndex-1
+            endif
+
+            let l:localBranchName=l:branch.name
+            let l:chosenRemote=l:remotes[l:chosenRemoteIndex]
+
+            let l:remoteBranchNameCanadidate=merginal#getRemoteBranchTrackedByLocalBranch(l:branch.name)
+            echo ' '
+            if !empty(l:remoteBranchNameCanadidate)
+                "Check that this is the same remote:
+                if l:remoteBranchNameCanadidate=~'\V\^'.escape(l:chosenRemote,'\').'/'
+                    "Remote the remote repository name
+                    let l:remoteBranchName=l:remoteBranchNameCanadidate[len(l:chosenRemote)+1:(-1)]
+                endif
+            endif
+        elseif l:branch.isRemote
+            let l:chosenRemote=l:branch.remote
+            if 'push'==a:remoteAction
+                "For push, we want to specify the remote branch name
+                let l:remoteBranchName=l:branch.name
+
+                let l:locals=merginal#getLocalBranchNamesThatTrackARemoteBranch(l:branch.handle)
+                if empty(l:locals)
+                    let l:localBranchName=l:branch.name
+                elseif 1==len(l:locals)
+                    let l:localBranchName=l:locals[0]
+                else
+                    let l:listForInputlist=map(copy(l:locals),'v:key+1.") ".v:val')
+                    call insert(l:listForInputlist,'Choose local branch to push `'.l:branch.handle.'` from:')
+                    let l:chosenLocalIndex=inputlist(l:listForInputlist)
+
+                    "Check that the chosen index is in range
+                    if l:chosenLocalIndex<=0 || len(l:locals)<l:chosenLocalIndex
+                        return
+                    endif
+
+                    let l:localBranchName=l:locals[l:chosenLocalIndex-1]
+                endif
+            else
+                "For pull and fetch, git automatically resolves the tracking
+                "branch based on the remote branch.
+                let l:localBranchName=l:branch.name
+            endif
+        endif
+
+        if exists('l:remoteBranchName') && empty(l:remoteBranchName)
+            unlet l:remoteBranchName
+        endif
+
+        let l:gitCommandWithArgs=[a:remoteAction]
+        if a:force
+            call add(l:gitCommandWithArgs,'--force')
+        endif
+
+        let l:reloadBuffers=0
+
+        "Pulling requires the --no-commit flag
+        if 'pull'==a:remoteAction
+            if exists('l:remoteBranchName')
+                let l:remoteBranchNameAsPrefix=shellescape(l:remoteBranchName).':'
+            else
+                let l:remoteBranchNameAsPrefix=''
+            endif
+            let l:remoteBranchEscapedName=l:remoteBranchNameAsPrefix.shellescape(l:localBranchName)
+            call add(l:gitCommandWithArgs,'--no-commit')
+            let l:reloadBuffers=1
+
+        elseif 'push'==a:remoteAction
+            if exists('l:remoteBranchName')
+                let l:remoteBranchNameAsSuffix=':'.shellescape(l:remoteBranchName)
+            else
+                let l:remoteBranchNameAsSuffix=''
+            endif
+            let l:remoteBranchEscapedName=shellescape(l:localBranchName).l:remoteBranchNameAsSuffix
+
+        elseif 'fetch'==a:remoteAction
+            if exists('l:remoteBranchName')
+                let l:targetBranchName=l:remoteBranchName
+            else
+                let l:targetBranchName=l:localBranchName
+            endif
+            let l:remoteBranchEscapedName=shellescape(l:targetBranchName)
+            execute '!'.b:merginal_repo.git_command(a:remoteAction).' '.shellescape(l:chosenRemote).' '.shellescape(l:targetBranchName)
+        endif
+        execute '!'.call(b:merginal_repo.git_command,l:gitCommandWithArgs,b:merginal_repo).' '.shellescape(l:chosenRemote).' '.l:remoteBranchEscapedName
+        if l:reloadBuffers
+            call merginal#reloadBuffers()
+        endif
+        call merginal#tryRefreshBranchListBuffer(0)
+    endif
+endfunction
+
+
+"Opens the diff files buffer
+function! s:diffWithBranchUnderCursor()
+    if 'Merginal:Branches'==bufname('')
+                \|| 'Merginal:RebaseAmend'==bufname('')
+        let l:branch=merginal#branchDetails('.')
+        if l:branch.isCurrent
+            throw 'Can not diff against the current branch'
+        endif
+        call merginal#openDiffFilesBuffer(l:branch)
+    endif
+endfunction
+
+
+"Prompts for a new name to the branch and renames it
+function! s:renameBranchUnderCursor()
+    if 'Merginal:Branches'==bufname('')
+        let l:branch=merginal#branchDetails('.')
+        if !l:branch.isLocal
+            throw 'Can not rename - not a local branch'
+        endif
+        let l:newName=input('Rename `'.l:branch.handle.'` to: ',l:branch.name)
+        echo ' '
+        if empty(l:newName)
+            echo 'Branch rename canceled by the user'
+            return
+        elseif l:newName==l:branch.name
+            echo 'Branch name was not modified'
+            return
+        endif
+
+        let l:gitCommand=b:merginal_repo.git_command('branch','-m',l:branch.name,l:newName)
+        let l:result=merginal#system(l:gitCommand)
+        echo l:result
+        call merginal#tryRefreshBranchListBuffer(0)
+    endif
+endfunction
+
+
+
+"Open the merge conflicts buffer for resolving merge conflicts
+function! merginal#openMergeConflictsBuffer(...)
+    let l:currentFile=expand('%:~:.')
+    if merginal#openTuiBuffer('Merginal:Conflicts',get(a:000,1,bufwinnr('Merginal:')))
+        doautocmd User Merginal_MergeConflicts
+    endif
+
+    "At any rate, refresh the buffer:
+    call merginal#tryRefreshMergeConflictsBuffer(l:currentFile)
+endfunction
+
+augroup merginal
+    autocmd User Merginal_MergeConflicts nnoremap <buffer> R :call merginal#tryRefreshMergeConflictsBuffer(0)<Cr>
+    autocmd User Merginal_MergeConflicts nnoremap <buffer> <Cr> :call <SID>openMergeConflictUnderCursor()<Cr>
+    autocmd User Merginal_MergeConflicts nnoremap <buffer> A :call <SID>addConflictedFileToStagingArea()<Cr>
+    autocmd User Merginal_MergeConflicts nnoremap <buffer> aa :call <SID>addConflictedFileToStagingArea()<Cr>
+augroup END
+
+"Returns 1 if all merges are done
+function! s:refreshConflictsBuffer(fileToJumpTo,headerLines)
+    "Get the list of unmerged files:
+    let l:conflicts=split(merginal#system(b:merginal_repo.git_command('ls-files','--unmerged')),'\r\n\|\n\|\r')
+    "Split by tab - the first part is info, the second is the file name
+    let l:conflicts=map(l:conflicts,'split(v:val,"\t")')
+    "Only take the stage 1 files - stage 2 and 3 are the same files with
+    "different hash, and we don't care about the hash here
+    let l:conflicts=filter(l:conflicts,'v:val[0] =~ "\\v 1$"')
+    "Take the file name - we no longer care about the info
+    let l:conflicts=map(l:conflicts,'v:val[1]')
+    "If the working copy is not the current dir, we can get wrong paths.
+    "We need to resulve that:
+    let l:conflicts=map(l:conflicts,'b:merginal_repo.tree(v:val)')
+    "Make the paths as short as possible:
+    let l:conflicts=map(l:conflicts,'fnamemodify(v:val,":~:.")')
+
+
+    let l:currentLine=line('.')-b:headerLinesCount
+
+    setlocal modifiable
+    "Clear the buffer:
+    normal ggdG
+    "Write the branch list:
+    call setline(1,a:headerLines+l:conflicts)
+    let b:headerLinesCount=len(a:headerLines)
+    let l:currentLine=l:currentLine+b:headerLinesCount
+    setlocal nomodifiable
+    if empty(l:conflicts)
+        return 1
+    endif
+
+    if empty(a:fileToJumpTo)
+        if 0<l:currentLine
+            execute l:currentLine
+        endif
+    else
+        let l:lineNumber=search('\V\^'+escape(a:fileToJumpTo,'\')+'\$','cnw')
+        if 0<l:lineNumber
+            execute l:lineNumber
+        else
+            execute l:currentLine
+        endif
+    endif
+    return 0
+endfunction
+
+"Returns 1 if all merges are done
+function! merginal#tryRefreshMergeConflictsBuffer(fileToJumpTo)
+    if 'Merginal:Conflicts'==bufname('')
+        return s:refreshConflictsBuffer(a:fileToJumpTo,[])
+    endif
+    return 0
+endfunction
+
+"Exactly what it says on tin
+function! s:openMergeConflictUnderCursor()
+    if 'Merginal:Conflicts'==bufname('')
+                \|| 'Merginal:Rebase'==bufname('')
+        let l:file=merginal#fileDetails('.')
+        if empty(l:file.name)
+            return
+        endif
+        call merginal#openFileDecidedWindow(b:merginal_repo,l:file.name)
+    endif
+endfunction
+
+"If that was the last merge conflict, automatically opens Fugitive's status
+"buffer
+function! s:addConflictedFileToStagingArea()
+    if 'Merginal:Conflicts'==bufname('')
+                \|| 'Merginal:Rebase'==bufname('')
+        let l:file=merginal#fileDetails('.')
+        if empty(l:file.name)
+            return
+        endif
+        echo merginal#runGitCommandInTreeReturnResult(b:merginal_repo,'--no-pager add '.shellescape(fnamemodify(l:file.name,':p')))
+
+        if 'Merginal:Conflicts'==bufname('')
+            if merginal#tryRefreshMergeConflictsBuffer(0)
+                "If this returns 1, that means this is the last branch, and we
+                "should open gufitive's status window
+                let l:mergeConflictsBuffer=bufnr('')
+                Gstatus
+                let l:gitStatusBuffer=bufnr('')
+                execute bufwinnr(l:mergeConflictsBuffer).'wincmd w'
+                wincmd q
+                execute bufwinnr(l:gitStatusBuffer).'wincmd w'
+            endif
+        else
+            if merginal#tryRefreshRebaseConflictsBuffer(0)
+                echo 'Added the last file of this patch.'
+                echo 'Continue to the next patch(y/n)?'
+                let l:answer=getchar()
+                if char2nr('y')==l:answer || char2nr('Y')==l:answer
+                    call s:rebaseAction('continue')
+                endif
+            endif
+        endif
+    endif
+endfunction
+
+
+"Open the diff files buffer for diffing agains another branch
+function! merginal#openDiffFilesBuffer(diffBranch,...)
+    if merginal#openTuiBuffer('Merginal:Diff',get(a:000,1,bufwinnr('Merginal:')))
+        doautocmd User Merginal_DiffFiles
+    endif
+
+    let b:merginal_diffBranch=a:diffBranch
+
+    "At any rate, refresh the buffer:
+    call merginal#tryRefreshDiffFilesBuffer()
+endfunction
+
+augroup merginal
+    autocmd User Merginal_DiffFiles nnoremap <buffer> R :call merginal#tryRefreshDiffFilesBuffer()<Cr>
+    autocmd User Merginal_DiffFiles nnoremap <buffer> <Cr> :call <SID>openDiffFileUnderCursor()<Cr>
+    autocmd User Merginal_DiffFiles nnoremap <buffer> ds :call <SID>openDiffFileUnderCursorAndDiff('s')<Cr>
+    autocmd User Merginal_DiffFiles nnoremap <buffer> dv :call <SID>openDiffFileUnderCursorAndDiff('v')<Cr>
+    autocmd User Merginal_DiffFiles nnoremap <buffer> co :call <SID>checkoutDiffFileUnderCursor()<Cr>
+augroup END
+
+
+"For the diff file in the specified line, retrieve:
+" - type: 'added', 'deleted' or 'modified'
+" - isAdded, isDeleted, isModified
+" - fileInTree: the path of the file relative to the repo
+" - fileFullPath: the full path to the file
+function! merginal#diffFileDetails(lineNumber)
+    if !exists('b:merginal_repo')
+        throw 'Unable to get diff file details outside the merginal window'
+    endif
+    let l:line=getline(a:lineNumber)
+    let l:result={}
+
+    let l:matches=matchlist(l:line,'\v([ADM])\t(.*)$')
+
+    if empty(l:matches)
+        throw 'Unable to get diff files details for `'.l:line.'`'
+    endif
+
+    let l:result.isAdded=0
+    let l:result.isDeleted=0
+    let l:result.isModified=0
+    if 'A'==l:matches[1]
+        let l:result.type='added'
+        let l:result.isAdded=1
+    elseif 'D'==l:matches[1]
+        let l:result.type='deleted'
+        let l:result.isDeleted=1
+    else
+        let l:result.type='modified'
+        let l:result.isModified=1
+    endif
+
+    let l:result.fileInTree=l:matches[2]
+    let l:result.fileFullPath=b:merginal_repo.tree(l:matches[2])
+
+    return l:result
+endfunction
+
+"If the current buffer is a branch list buffer - refresh it!
+function! merginal#tryRefreshDiffFilesBuffer()
+    if 'Merginal:Diff'==bufname('')
+        let l:diffBranch=b:merginal_diffBranch
+        let l:diffFiles=merginal#runGitCommandInTreeReturnResultLines(b:merginal_repo,'diff --name-status '.shellescape(l:diffBranch.handle))
+        let l:currentLine=line('.')
+
+        setlocal modifiable
+        "Clear the buffer:
+        normal ggdG
+        "Write the diff files list:
+        call setline(1,l:diffFiles)
+        setlocal nomodifiable
+
+        execute l:currentLine
+    endif
+endfunction
+
+"Exactly what it says on tin
+function! s:openDiffFileUnderCursor()
+    if 'Merginal:Diff'==bufname('')
+        let l:diffFile=merginal#diffFileDetails('.')
+
+        if l:diffFile.isDeleted
+            throw 'File does not exist in current buffer'
+        endif
+
+        call merginal#openFileDecidedWindow(b:merginal_repo,l:diffFile.fileFullPath)
+    endif
+endfunction
+
+"Exactly what it says on tin
+function! s:openDiffFileUnderCursorAndDiff(diffType)
+    if a:diffType!='s' && a:diffType!='v'
+        throw 'Bad diff type'
+    endif
+    if 'Merginal:Diff'==bufname('')
+        let l:diffFile=merginal#diffFileDetails('.')
+
+        if l:diffFile.isAdded
+            throw 'File does not exist in other buffer'
+        endif
+
+        let l:repo=b:merginal_repo
+        let l:diffBranch=b:merginal_diffBranch
+
+        "Close currently open git diffs
+        let l:currentWindowBuffer=winbufnr('.')
+        try
+            windo if 'blob'==get(b:,'fugitive_type','') && exists('w:fugitive_diff_restore')
+                        \| bdelete
+                        \| endif
+        catch
+            "do nothing
+        finally
+            execute bufwinnr(l:currentWindowBuffer).'wincmd w'
+        endtry
+
+        call merginal#openFileDecidedWindow(l:repo,l:diffFile.fileFullPath)
+
+        execute ':G'.a:diffType.'diff '.fnameescape(l:diffBranch.handle)
+    endif
+endfunction
+
+"Checks out the file from the other branch to the current branch
+function! s:checkoutDiffFileUnderCursor()
+    if 'Merginal:Diff'==bufname('')
+        let l:diffFile=merginal#diffFileDetails('.')
+
+        if l:diffFile.isAdded
+            throw 'File does not exist in diffed buffer'
+        endif
+
+        let l:answer=1
+        if !empty(glob(l:diffFile.fileFullPath))
+            let l:answer='yes'==input('Override `'.l:diffFile.fileInTree.'`?(type "yes" to confirm) ')
+        endif
+        if l:answer
+            echo merginal#runGitCommandInTreeReturnResult(b:merginal_repo,'--no-pager checkout '.shellescape(b:merginal_diffBranch.handle)
+                        \.' -- '.shellescape(l:diffFile.fileFullPath))
+            call merginal#reloadBuffers()
+            call merginal#tryRefreshDiffFilesBuffer()
+        else
+            echo ' '
+            echo 'File checkout canceled by the user'
+        endif
+    endif
+endfunction
+
+
+"Open the rebase conflicts buffer for resolving rebase conflicts
+function! merginal#openRebaseConflictsBuffer(...)
+    let l:currentFile=expand('%:~:.')
+    if merginal#openTuiBuffer('Merginal:Rebase',get(a:000,1,bufwinnr('Merginal:')))
+        doautocmd User Merginal_RebaseConflicts
+    endif
+
+    "At any rate, refresh the buffer:
+    call merginal#tryRefreshRebaseConflictsBuffer(l:currentFile)
+endfunction
+
+augroup merginal
+    autocmd User Merginal_RebaseConflicts nnoremap <buffer> R :call merginal#tryRefreshRebaseConflictsBuffer(0)<Cr>
+    autocmd User Merginal_RebaseConflicts nnoremap <buffer> <Cr> :call <SID>openMergeConflictUnderCursor()<Cr>
+    autocmd User Merginal_RebaseConflicts nnoremap <buffer> A :call <SID>addConflictedFileToStagingArea()<Cr>
+    autocmd User Merginal_RebaseConflicts nnoremap <buffer> aa :call <SID>addConflictedFileToStagingArea()<Cr>
+    autocmd User Merginal_RebaseConflicts nnoremap <buffer> ra :call <SID>rebaseAction('abort')<Cr>
+    autocmd User Merginal_RebaseConflicts nnoremap <buffer> rs :call <SID>rebaseAction('skip')<Cr>
+    autocmd User Merginal_RebaseConflicts nnoremap <buffer> rc :call <SID>rebaseAction('continue')<Cr>
+augroup END
+
+"Returns 1 if all rebase conflicts are done
+function! merginal#tryRefreshRebaseConflictsBuffer(fileToJumpTo)
+    if 'Merginal:Rebase'==bufname('')
+        let l:currentCommitMessageLines=readfile(b:merginal_repo.dir('rebase-apply','msg-clean'))
+        call insert(l:currentCommitMessageLines,'=== Reapplying: ===')
+        call add(l:currentCommitMessageLines,'===================')
+        call add(l:currentCommitMessageLines,'')
+        return s:refreshConflictsBuffer(a:fileToJumpTo,l:currentCommitMessageLines)
+    endif
+    return 0
+endfunction
+
+"Run various rebase actions
+function! s:rebaseAction(remoteAction)
+    if 'Merginal:Rebase'==bufname('')
+                \|| 'Merginal:RebaseAmend'==bufname('')
+        echo merginal#runGitCommandInTreeReturnResult(b:merginal_repo,'--no-pager rebase --'.a:remoteAction)
+        call merginal#reloadBuffers()
+        if merginal#isRebaseMode()
+            call merginal#tryRefreshRebaseConflictsBuffer(0)
+        elseif merginal#isRebaseAmendMode()
+            call merginal#tryRefreshRebaseAmendBuffer()
+        else
+            "If we finished rebasing - close the rebase conflicts buffer
+            wincmd q
+        endif
+    endif
+endfunction
+
+
+
+"Open the rebase amend buffer
+function! merginal#openRebaseAmendBuffer(...)
+    let l:currentFile=expand('%:~:.')
+    if merginal#openTuiBuffer('Merginal:RebaseAmend',get(a:000,1,bufwinnr('Merginal:')))
+        doautocmd User Merginal_RebaseAmend
+    endif
+
+    "At any rate, refresh the buffer:
+    call merginal#tryRefreshRebaseAmendBuffer()
+endfunction
+
+autocmd User Merginal_RebaseAmend nnoremap <buffer> R :call merginal#tryRefreshRebaseAmendBuffer()<Cr>
+autocmd User Merginal_RebaseAmend nnoremap <buffer> ra :call <SID>rebaseAction('abort')<Cr>
+autocmd User Merginal_RebaseAmend nnoremap <buffer> rs :call <SID>rebaseAction('skip')<Cr>
+autocmd User Merginal_RebaseAmend nnoremap <buffer> rc :call <SID>rebaseAction('continue')<Cr>
+autocmd User Merginal_RebaseAmend nnoremap <buffer> gd :call <SID>diffWithBranchUnderCursor()<Cr>
+
+function! merginal#tryRefreshRebaseAmendBuffer()
+    if 'Merginal:RebaseAmend'==bufname('')
+        "let l:gitStatusOutput=split(merginal#system(b:merginal_repo.git_command('status','--all')),'\r\n\|\n\|\r')
+        let l:currentLine=line('.')
+        let l:newBufferLines=[]
+        let l:amendedCommit=readfile(b:merginal_repo.dir('rebase-merge','amend'))
+        let l:amendedCommitShort=merginal#system(b:merginal_repo.git_command('rev-parse','--short',l:amendedCommit[0]))
+        let l:amendedCommitShort=substitute(l:amendedCommitShort,'\v[\r\n]','','g')
+        let l:amendedCommitMessage=readfile(b:merginal_repo.dir('rebase-merge','message'))
+        call add(l:newBufferLines,'=== Amending '.l:amendedCommitShort.' ===')
+        let l:newBufferLines+=l:amendedCommitMessage
+        call add(l:newBufferLines,repeat('=',len(l:newBufferLines[0])))
+        call add(l:newBufferLines,'')
+
+        let b:headerLinesCount=len(l:newBufferLines)+1
+
+        let l:branchList=split(merginal#system(b:merginal_repo.git_command('branch','--all')),'\r\n\|\n\|\r')
+        "The first line is a reminder that we are rebasing
+        "call remove(l:branchList,0)
+        let l:newBufferLines+=l:branchList
+
+
+        setlocal modifiable
+        "Clear the buffer:
+        normal ggdG
+        "Write the new buffer lines:
+        call setline(1,l:newBufferLines)
+        "call setline(1,l:branchList)
+        setlocal nomodifiable
+    endif
+    return 0
+endfunction
diff --git a/vimfiles/doc/merginal.txt b/vimfiles/doc/merginal.txt
new file mode 100755
index 0000000..124d252
--- /dev/null
+++ b/vimfiles/doc/merginal.txt
@@ -0,0 +1,142 @@
+*merginal.txt*
+
+
+Author:  Idan Arye <https://github.com/idanarye/>
+License: Same terms as Vim itself (see |license|)
+
+Version: 1.4.0
+
+INTRODUCTION                                                      *merginal*
+
+Merginal aims provide a nice inteface for dealing with Git branches.  It
+offers interactive TUI for:
+
+* Viewing the list of branches
+* Checking out branches from that list
+* Creating new branches
+* Deleting branches
+* Merging branches
+* Rebasing branches
+* Solving merge conflicts
+* Renaming branches
+
+
+REQUIREMENTS                                         *merginal-requirements*
+
+Merginal is based on Fugitive, so it requires Fugitive. If you don't have it
+already you can get it from https://github.com/tpope/vim-fugitive
+
+It should go without saying that you need Git.
+
+Under Windows, vimproc is an optional requirement. Merginal will work without
+it, but it'll pop an ugly console window every time it needs to run a Git
+command. You can get vimproc from https://github.com/Shougo/vimproc.vim
+
+
+USAGE                                                       *merginal-usage*
+
+To use Merginal you need to know but one command: *:Merginal*. It'll open the
+|merginal-branch-list| buffer, unless the repository is in merge mode then
+it'll open the |merginal-merge-conflicts| buffer.
+
+Like Fugitive's commands, |:Merginal| is native to the buffer, and will only
+work in buffers that are parts of Git repositories.
+
+You can also toggle the buffer with |:MerginalToggle| or close it with
+|:MerginalClose|.
+
+
+THE BRANCH LIST                                       *merginal-branch-list*
+
+The branch list shows a list of branches. While in that list, you can use the
+following keymaps to interact with the branches:
+
+R      Refresh the buffer list.
+cc     Checkout the branch under the cursor.
+ct     Track the remote branch under the cursor.
+cT     Track the remote branch under the cursor, prompting for a name.
+C      Same as cc.
+aa     Create a new branch from the currently checked out branch. You'll be
+       prompted to enter a name for the new branch.
+A      Same as aa.
+dd     Delete the branch under the cursor.
+D      Same as dd.
+mm     Merge the branch under the cursor into the currently checked out
+       branch. If there are merge conflicts, the |merginal-merge-conflicts|
+       buffer will open in place of the branch list buffer.
+M      Same as mm.
+mf     Merge the branch under the cursor into the currently checked out branch
+       using Fugitive's |:Gmerge| command.
+rb     Rebase the currently checked out branch against the branch under the
+       cursor. If there are rebase conflicts, the |merginal-rebase-conflicts|
+       buffer will open in place of
+       the branch list buffer.
+ps     Prompt to choose a remote to push the branch under the cursor.
+pS     Prompt to choose a remote to force push the branch under the cursor.
+pl     Prompt to choose a remote to pull the branch under the cursor.
+pf     Prompt to choose a remote to fetch the branch under the cursor.
+gd     Open |merginal-diff-files| buffer to diff against the branch under the
+       cursor.
+rn     Prompt to rename the branch under the cursor.
+
+
+MERGE CONFLICTS                                   *merginal-merge-conflicts*
+
+The merge conflicts buffer is used to solve merge conflicts. It shows all the
+files that have merge conflicts and offers the following keymaps:
+
+R      Refresh the merge conflicts list.
+<Cr>   Open the conflicted file under the cursor.
+aa     Add the conflicted file under the cursor to the staging area. If that
+       was the last conflicted file, the merge conflicts buffer will close and
+       |fugitive-:Gstatus| will open.
+A      Same as aa.
+
+
+REBASE CONFLICTS                                 *merginal-rebase-conflicts*
+
+The rebase conflicts buffer is used to solve rebase conflicts. It shows the
+currently applied commit message and all the files that have rebase conflicts,
+and offers the following keymaps:
+
+R      Refresh the rebase conflicts list.
+<Cr>   Open the conflicted file under the cursor.
+aa     Add the conflicted file under the cursor to the staging area. If that
+       was the last conflicted file, prompt the user to continue to the next
+       patch.
+A      Same as aa.
+ra     Abort the rebase
+rc     Continue to the next patch.
+rs     Skip the current patch
+
+
+REBASE AMEND                                         *merginal-rebase-amend*
+
+The rebase amend buffer is shown when you amend a patch during a rebase. It
+shows the amended commit's shortened hash and commit message. Additionally, it
+shows all the branches so you can diff against them while the patch. If offers
+the folloing keymaps:
+
+R      Refresh the rebase amend buffer.
+gd     Open |merginal-diff-files| buffer to diff against the branch under the
+       cursor.
+ra     Abort the rebase
+rc     Continue to the next patch.
+rs     Skip the current patch
+
+
+DIFF FILES                                             *merginal-diff-files*
+
+The diff files buffer is used to diff against another branch. It displays all
+the differences between the currently checked out branch and the branch it was
+opened against, and offerts the following keymaps:
+
+R      Refresh the diff files list.
+<Cr>   Open the file under the cursor(if it exists in the currently checked
+       out branch).
+ds     Split-diff against the file under the cursor(if it exists in the other
+       branch)
+ds     VSplit-diff against the file under the cursor(if it exists in the other
+       branch)
+co     Check out the file under the cursor(if it exists in the other branch)
+       into the current branch.
diff --git a/vimfiles/doc/tags b/vimfiles/doc/tags
index 90177b7..6b7fb68 100644
--- a/vimfiles/doc/tags
+++ b/vimfiles/doc/tags
@@ -1940,6 +1940,15 @@ matchit-troubleshoot	matchit.txt	/*matchit-troubleshoot*
 matchit-v_%	matchit.txt	/*matchit-v_%*
 matchit.txt	matchit.txt	/*matchit.txt*
 matchit.vim	matchit.txt	/*matchit.vim*
+merginal	merginal.txt	/*merginal*
+merginal-branch-list	merginal.txt	/*merginal-branch-list*
+merginal-diff-files	merginal.txt	/*merginal-diff-files*
+merginal-merge-conflicts	merginal.txt	/*merginal-merge-conflicts*
+merginal-rebase-amend	merginal.txt	/*merginal-rebase-amend*
+merginal-rebase-conflicts	merginal.txt	/*merginal-rebase-conflicts*
+merginal-requirements	merginal.txt	/*merginal-requirements*
+merginal-usage	merginal.txt	/*merginal-usage*
+merginal.txt	merginal.txt	/*merginal.txt*
 n_<Plug>TComment-Comment	tcomment.txt	/*n_<Plug>TComment-Comment*
 n_<Plug>TComment-Commentb	tcomment.txt	/*n_<Plug>TComment-Commentb*
 n_<Plug>TComment-Commentc	tcomment.txt	/*n_<Plug>TComment-Commentc*
diff --git a/vimfiles/plugin/merginal.vim b/vimfiles/plugin/merginal.vim
new file mode 100755
index 0000000..1cda509
--- /dev/null
+++ b/vimfiles/plugin/merginal.vim
@@ -0,0 +1,51 @@
+function! s:openBasedOnMergeMode() abort
+    if merginal#isRebaseMode()
+        call merginal#openRebaseConflictsBuffer()
+    elseif merginal#isRebaseAmendMode()
+        call merginal#openRebaseAmendBuffer()
+    elseif merginal#isMergeMode()
+        call merginal#openMergeConflictsBuffer()
+    else
+        call merginal#openBranchListBuffer()
+    endif
+endfunction
+
+function! s:toggleBasedOnMergeMode() abort
+    let l:repo=fugitive#repo()
+    let l:merginalWindowNumber=bufwinnr('Merginal:')
+    if 0<=l:merginalWindowNumber
+        let l:merginalBufferNumber=winbufnr(l:merginalWindowNumber)
+        let l:merginalBufferName=bufname(l:merginalBufferNumber)
+
+        "If we are not on the same dir we need to reload the merginal buffer
+        "anyways:
+        if getbufvar(l:merginalBufferNumber,'merginal_repo').dir()==l:repo.dir()
+            if merginal#isRebaseMode()
+                if 'Merginal:Rebase'==l:merginalBufferName
+                    call merginal#closeMerginalBuffer()
+                    return
+                endif
+            elseif merginal#isRebaseAmendMode()
+                if 'Merginal:RebaseAmend'==l:merginalBufferName
+                    call merginal#closeMerginalBuffer()
+                    return
+                endif
+            elseif merginal#isMergeMode()
+                if 'Merginal:Conflicts'==l:merginalBufferName
+                    call merginal#closeMerginalBuffer()
+                    return
+                endif
+            else
+                if 'Merginal:Branches'==l:merginalBufferName
+                    call merginal#closeMerginalBuffer()
+                    return
+                endif
+            end
+        endif
+    endif
+    call s:openBasedOnMergeMode()
+endfunction
+
+autocmd User Fugitive command! -buffer -nargs=0 Merginal call s:openBasedOnMergeMode()
+autocmd User Fugitive command! -buffer -nargs=0 MerginalToggle call s:toggleBasedOnMergeMode()
+autocmd User Fugitive command! -buffer -nargs=0 MerginalClose call merginal#closeMerginalBuffer()